CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers" {:query-params {:isGroupbySite ""
                                                                                                                                                     :nextPartitionKey ""
                                                                                                                                                     :nextRowKey ""}})

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey="

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey="))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers',
  params: {isGroupbySite: '', nextPartitionKey: '', nextRowKey: ''}
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers',
  qs: {isGroupbySite: '', nextPartitionKey: '', nextRowKey: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers');

req.query({
  isGroupbySite: '',
  nextPartitionKey: '',
  nextRowKey: ''
});

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers',
  params: {isGroupbySite: '', nextPartitionKey: '', nextRowKey: ''}
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'isGroupbySite' => '',
  'nextPartitionKey' => '',
  'nextRowKey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'isGroupbySite' => '',
  'nextPartitionKey' => '',
  'nextRowKey' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers"

querystring = {"isGroupbySite":"","nextPartitionKey":"","nextRowKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers"

queryString <- list(
  isGroupbySite = "",
  nextPartitionKey = "",
  nextRowKey = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers') do |req|
  req.params['isGroupbySite'] = ''
  req.params['nextPartitionKey'] = ''
  req.params['nextRowKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers";

    let querystring = [
        ("isGroupbySite", ""),
        ("nextPartitionKey", ""),
        ("nextRowKey", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addomainservicemembers?isGroupbySite=&nextPartitionKey=&nextRowKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"

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

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

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

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

}

DELETE /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/addsservicemembers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/credentials")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationstatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"

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

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

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

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

}

POST /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

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

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

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

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

}

POST /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

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

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

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

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

}

DELETE /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/features/:featureName/userpreference")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"

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

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

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

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

}

POST /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices');

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}}/providers/Microsoft.ADHybridHealthService/addsservices'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/forestsummary")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata/:metricName/groups/:groupName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices');

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}}/providers/Microsoft.ADHybridHealthService/addsservices'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metricmetadata")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/average")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/metrics/:metricName/groups/:groupName/sum")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails"

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails'
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails'
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationdetails")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary" {:query-params {:isGroupbySite ""
                                                                                                                                                 :query ""
                                                                                                                                                 :nextPartitionKey ""
                                                                                                                                                 :nextRowKey ""}})

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey="

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

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

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

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

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey="))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary',
  params: {isGroupbySite: '', query: '', nextPartitionKey: '', nextRowKey: ''}
};

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary',
  qs: {isGroupbySite: '', query: '', nextPartitionKey: '', nextRowKey: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary');

req.query({
  isGroupbySite: '',
  query: '',
  nextPartitionKey: '',
  nextRowKey: ''
});

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary',
  params: {isGroupbySite: '', query: '', nextPartitionKey: '', nextRowKey: ''}
};

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

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

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=" in

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

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'isGroupbySite' => '',
  'query' => '',
  'nextPartitionKey' => '',
  'nextRowKey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'isGroupbySite' => '',
  'query' => '',
  'nextPartitionKey' => '',
  'nextRowKey' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=")

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

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

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary"

querystring = {"isGroupbySite":"","query":"","nextPartitionKey":"","nextRowKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary"

queryString <- list(
  isGroupbySite = "",
  query = "",
  nextPartitionKey = "",
  nextRowKey = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary') do |req|
  req.params['isGroupbySite'] = ''
  req.params['query'] = ''
  req.params['nextPartitionKey'] = ''
  req.params['nextRowKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary";

    let querystring = [
        ("isGroupbySite", ""),
        ("query", ""),
        ("nextPartitionKey", ""),
        ("nextRowKey", ""),
    ];

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

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/replicationsummary?isGroupbySite=&query=&nextPartitionKey=&nextRowKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/servicemembers/:serviceMemberId/alerts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/alerts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/configuration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension"))
    .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension")
  .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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension');

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}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/addsservices/:serviceName/dimensions/:dimension")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/alerts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/alerts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/providers/Microsoft.ADHybridHealthService/configuration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/configuration',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');

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}}/providers/Microsoft.ADHybridHealthService/configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/providers/Microsoft.ADHybridHealthService/configuration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/providers/Microsoft.ADHybridHealthService/configuration') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/configuration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"))
    .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}}/providers/Microsoft.ADHybridHealthService/configuration")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")
  .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}}/providers/Microsoft.ADHybridHealthService/configuration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/configuration',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');

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}}/providers/Microsoft.ADHybridHealthService/configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/configuration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/configuration') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

	req, _ := http.NewRequest("PATCH", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/providers/Microsoft.ADHybridHealthService/configuration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"))
    .method("PATCH", 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}}/providers/Microsoft.ADHybridHealthService/configuration")
  .patch(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")
  .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('PATCH', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration';
const options = {method: 'PATCH'};

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}}/providers/Microsoft.ADHybridHealthService/configuration',
  method: 'PATCH',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")
  .patch(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/configuration',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

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}}/providers/Microsoft.ADHybridHealthService/configuration" in

Client.call `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration' -Method PATCH 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration' -Method PATCH 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PATCH", "/baseUrl/providers/Microsoft.ADHybridHealthService/configuration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

response = requests.patch(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration"

response <- VERB("PATCH", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/providers/Microsoft.ADHybridHealthService/configuration') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PATCH {{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration

wget --quiet \
  --method PATCH \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/configuration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

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}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps"))
    .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}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps")
  .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}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps');

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}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/reports/DevOps/IsDevOps")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/feedback")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/feedbacktype/alerts/:shortName/alertfeedback")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/metrics/:metricName/groups/:groupName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata/:metricName/groups/:groupName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metricmetadata")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/average")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/metrics/:metricName/groups/:groupName/sum")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/operations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/operations',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/operations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/operations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/operations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/blobUris")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/riskyIp/generateBlobUri")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/reports/badpassword/details/user")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/data")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/serviceconfiguration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors"))
    .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}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors")
  .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}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors');

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}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/service/:serviceName/servicemembers/:serviceMemberId/connectors")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/credentials")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness")

require "http/client"

url = "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness"))
    .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness")
  .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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness');

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}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness');

echo $response->getBody();

setUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/providers/Microsoft.ADHybridHealthService/services/:serviceName/servicemembers/:serviceMemberId/datafreshness');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();