API Key Custom Role

curl -X POST "https://status200.ru/api/api-key-custom-role/get-list?skip=0&limit=10" \
  -H "Content-Type: application/json" \
  -H "ApiKey: YOUR_API_KEY" \
  -d '{
    "select": {
      "apiKeyId": true,
      "customRoleId": true,
      "projectId": true,
      "apiKey": true,
      "createdByUser": true
    },
    "query": {},
    "sort": {
      "createdAt": -1
    }
  }'

const axios = require('axios');

const response = await axios({
  method: 'post',
  url: 'https://status200.ru/api/api-key-custom-role/get-list?skip=0&limit=10',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "select": {
      "apiKeyId": true,
      "customRoleId": true,
      "projectId": true,
      "apiKey": true,
      "createdByUser": true
    },
    "query": {},
    "sort": {
      "createdAt": -1
    }
  }
});

console.log(response.data);

import axios, { AxiosResponse } from 'axios';

interface ApiResponse {
  // Define your response type here
  [key: string]: unknown;
}

const response: AxiosResponse<ApiResponse> = await axios({
  method: 'post',
  url: 'https://status200.ru/api/api-key-custom-role/get-list?skip=0&limit=10',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "select": {
      "apiKeyId": true,
      "customRoleId": true,
      "projectId": true,
      "apiKey": true,
      "createdByUser": true
    },
    "query": {},
    "sort": {
      "createdAt": -1
    }
  }
});

console.log(response.data);

import requests

url = "https://status200.ru/api/api-key-custom-role/get-list?skip=0&limit=10"
headers = {
    "Content-Type": "application/json",
    "ApiKey": "YOUR_API_KEY"
}

payload = {
    "select": {
        "apiKeyId": True,
        "customRoleId": True,
        "projectId": True,
        "apiKey": True,
        "createdByUser": True
    },
    "query": {

    },
    "sort": {
        "createdAt": -1
    }
}

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

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    payload := map[string]interface{}{
        "select": map[string]interface{}{"apiKeyId": true, "customRoleId": true, "projectId": true, "apiKey": true, "createdByUser": true},
        "query": map[string]interface{}{},
        "sort": map[string]interface{}{"createdAt": -1},
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://status200.ru/api/api-key-custom-role/get-list?skip=0&limit=10", bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("ApiKey", "YOUR_API_KEY")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiRequest {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        String jsonBody = "{\n          \"select\": {\n                    \"apiKeyId\": true,\n                    \"customRoleId\": true,\n                    \"projectId\": true,\n                    \"apiKey\": true,\n                    \"createdByUser\": true\n          },\n          \"query\": {},\n          \"sort\": {\n                    \"createdAt\": -1\n          }\n}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://status200.ru/api/api-key-custom-role/get-list?skip=0&limit=10"))
            .header("Content-Type", "application/json")
            .header("ApiKey", "YOUR_API_KEY")
            .method("POST", HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();

        client.DefaultRequestHeaders.Add("ApiKey", "YOUR_API_KEY");

        var json = @"{
        ""select"": {
                ""apiKeyId"": true,
                ""customRoleId"": true,
                ""projectId"": true,
                ""apiKey"": true,
                ""createdByUser"": true
        },
        ""query"": {},
        ""sort"": {
                ""createdAt"": -1
        }
}";
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync(
            "https://status200.ru/api/api-key-custom-role/get-list?skip=0&limit=10", content);

        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}

<?php

$url = "https://status200.ru/api/api-key-custom-role/get-list?skip=0&limit=10";

$headers = [
    "Content-Type: application/json",
    "ApiKey: YOUR_API_KEY"
];

$data = [
    "select" => [
        "apiKeyId" => true,
        "customRoleId" => true,
        "projectId" => true,
        "apiKey" => true,
        "createdByUser" => true
    ],
    "query" => [

    ],
    "sort" => [
        "createdAt" => -1
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);
?>

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse("https://status200.ru/api/api-key-custom-role/get-list?skip=0&limit=10")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri.request_uri)
request["Content-Type"] = "application/json"
request["ApiKey"] = "YOUR_API_KEY"

request.body = {
  "select" => {
    "apiKeyId" => true,
    "customRoleId" => true,
    "projectId" => true,
    "apiKey" => true,
    "createdByUser" => true
  },
  "query" => {

  },
  "sort" => {
    "createdAt" => -1
  }
}.to_json

response = http.request(request)
puts JSON.parse(response.body)

use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    headers.insert("ApiKey", HeaderValue::from_static("YOUR_API_KEY"));

    let body = json!({
    "select": {
        "apiKeyId": true,
        "customRoleId": true,
        "projectId": true,
        "apiKey": true,
        "createdByUser": true
    },
    "query": {

    },
    "sort": {
        "createdAt": -1
    }
});

    let response = client
        .post("https://status200.ru/api/api-key-custom-role/get-list?skip=0&limit=10")
        .headers(headers)
        .json(&body)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:#?}", result);

    Ok(())
}

$headers = @{
    "Content-Type" = "application/json"
    "ApiKey" = "YOUR_API_KEY"
}

$body = @{
    select = @{
        apiKeyId = $true
        customRoleId = $true
        projectId = $true
        apiKey = $true
        createdByUser = $true
    }
    query = @{

    }
    sort = @{
        createdAt = -1
    }
} | ConvertTo-Json -Depth 10

$response = Invoke-RestMethod -Uri "https://status200.ru/api/api-key-custom-role/get-list?skip=0&limit=10" -Method POST -Headers $headers -Body $body
$response | ConvertTo-Json -Depth 10

curl -X POST "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5/get-item" \
  -H "Content-Type: application/json" \
  -H "ApiKey: YOUR_API_KEY" \
  -d '{
    "select": {
      "apiKeyId": true,
      "customRoleId": true,
      "projectId": true,
      "apiKey": true,
      "createdByUser": true
    }
  }'

const axios = require('axios');

const response = await axios({
  method: 'post',
  url: 'https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5/get-item',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "select": {
      "apiKeyId": true,
      "customRoleId": true,
      "projectId": true,
      "apiKey": true,
      "createdByUser": true
    }
  }
});

console.log(response.data);

import axios, { AxiosResponse } from 'axios';

interface ApiResponse {
  // Define your response type here
  [key: string]: unknown;
}

const response: AxiosResponse<ApiResponse> = await axios({
  method: 'post',
  url: 'https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5/get-item',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "select": {
      "apiKeyId": true,
      "customRoleId": true,
      "projectId": true,
      "apiKey": true,
      "createdByUser": true
    }
  }
});

console.log(response.data);

import requests

url = "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5/get-item"
headers = {
    "Content-Type": "application/json",
    "ApiKey": "YOUR_API_KEY"
}

payload = {
    "select": {
        "apiKeyId": True,
        "customRoleId": True,
        "projectId": True,
        "apiKey": True,
        "createdByUser": True
    }
}

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

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    payload := map[string]interface{}{
        "select": map[string]interface{}{"apiKeyId": true, "customRoleId": true, "projectId": true, "apiKey": true, "createdByUser": true},
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5/get-item", bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("ApiKey", "YOUR_API_KEY")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiRequest {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        String jsonBody = "{\n          \"select\": {\n                    \"apiKeyId\": true,\n                    \"customRoleId\": true,\n                    \"projectId\": true,\n                    \"apiKey\": true,\n                    \"createdByUser\": true\n          }\n}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5/get-item"))
            .header("Content-Type", "application/json")
            .header("ApiKey", "YOUR_API_KEY")
            .method("POST", HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();

        client.DefaultRequestHeaders.Add("ApiKey", "YOUR_API_KEY");

        var json = @"{
        ""select"": {
                ""apiKeyId"": true,
                ""customRoleId"": true,
                ""projectId"": true,
                ""apiKey"": true,
                ""createdByUser"": true
        }
}";
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync(
            "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5/get-item", content);

        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}

<?php

$url = "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5/get-item";

$headers = [
    "Content-Type: application/json",
    "ApiKey: YOUR_API_KEY"
];

$data = [
    "select" => [
        "apiKeyId" => true,
        "customRoleId" => true,
        "projectId" => true,
        "apiKey" => true,
        "createdByUser" => true
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);
?>

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse("https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5/get-item")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri.request_uri)
request["Content-Type"] = "application/json"
request["ApiKey"] = "YOUR_API_KEY"

request.body = {
  "select" => {
    "apiKeyId" => true,
    "customRoleId" => true,
    "projectId" => true,
    "apiKey" => true,
    "createdByUser" => true
  }
}.to_json

response = http.request(request)
puts JSON.parse(response.body)

use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    headers.insert("ApiKey", HeaderValue::from_static("YOUR_API_KEY"));

    let body = json!({
    "select": {
        "apiKeyId": true,
        "customRoleId": true,
        "projectId": true,
        "apiKey": true,
        "createdByUser": true
    }
});

    let response = client
        .post("https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5/get-item")
        .headers(headers)
        .json(&body)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:#?}", result);

    Ok(())
}

$headers = @{
    "Content-Type" = "application/json"
    "ApiKey" = "YOUR_API_KEY"
}

$body = @{
    select = @{
        apiKeyId = $true
        customRoleId = $true
        projectId = $true
        apiKey = $true
        createdByUser = $true
    }
} | ConvertTo-Json -Depth 10

$response = Invoke-RestMethod -Uri "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5/get-item" -Method POST -Headers $headers -Body $body
$response | ConvertTo-Json -Depth 10

curl -X POST "https://status200.ru/api/api-key-custom-role/count" \
  -H "Content-Type: application/json" \
  -H "ApiKey: YOUR_API_KEY" \
  -d '{
    "query": {}
  }'

const axios = require('axios');

const response = await axios({
  method: 'post',
  url: 'https://status200.ru/api/api-key-custom-role/count',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "query": {}
  }
});

console.log(response.data);

import axios, { AxiosResponse } from 'axios';

interface ApiResponse {
  // Define your response type here
  [key: string]: unknown;
}

const response: AxiosResponse<ApiResponse> = await axios({
  method: 'post',
  url: 'https://status200.ru/api/api-key-custom-role/count',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "query": {}
  }
});

console.log(response.data);

import requests

url = "https://status200.ru/api/api-key-custom-role/count"
headers = {
    "Content-Type": "application/json",
    "ApiKey": "YOUR_API_KEY"
}

payload = {
    "query": {

    }
}

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

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    payload := map[string]interface{}{
        "query": map[string]interface{}{},
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://status200.ru/api/api-key-custom-role/count", bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("ApiKey", "YOUR_API_KEY")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiRequest {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        String jsonBody = "{\n          \"query\": {}\n}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://status200.ru/api/api-key-custom-role/count"))
            .header("Content-Type", "application/json")
            .header("ApiKey", "YOUR_API_KEY")
            .method("POST", HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();

        client.DefaultRequestHeaders.Add("ApiKey", "YOUR_API_KEY");

        var json = @"{
        ""query"": {}
}";
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync(
            "https://status200.ru/api/api-key-custom-role/count", content);

        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}

<?php

$url = "https://status200.ru/api/api-key-custom-role/count";

$headers = [
    "Content-Type: application/json",
    "ApiKey: YOUR_API_KEY"
];

$data = [
    "query" => [

    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);
?>

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse("https://status200.ru/api/api-key-custom-role/count")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri.request_uri)
request["Content-Type"] = "application/json"
request["ApiKey"] = "YOUR_API_KEY"

request.body = {
  "query" => {

  }
}.to_json

response = http.request(request)
puts JSON.parse(response.body)

use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    headers.insert("ApiKey", HeaderValue::from_static("YOUR_API_KEY"));

    let body = json!({
    "query": {

    }
});

    let response = client
        .post("https://status200.ru/api/api-key-custom-role/count")
        .headers(headers)
        .json(&body)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:#?}", result);

    Ok(())
}

$headers = @{
    "Content-Type" = "application/json"
    "ApiKey" = "YOUR_API_KEY"
}

$body = @{
    query = @{

    }
} | ConvertTo-Json -Depth 10

$response = Invoke-RestMethod -Uri "https://status200.ru/api/api-key-custom-role/count" -Method POST -Headers $headers -Body $body
$response | ConvertTo-Json -Depth 10

curl -X POST "https://status200.ru/api/api-key-custom-role" \
  -H "Content-Type: application/json" \
  -H "ApiKey: YOUR_API_KEY" \
  -d '{
    "data": {
      "apiKeyId": "e1f2a3b4-c5d6-4e7f-8a9b-0c1d2e3f4a5b",
      "customRoleId": "7a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d",
      "projectId": "a3f9c8e2-d4b6-4a7c-9e5f-1a2b3c4d5e6f",
      "apiKey": "Production API Key",
      "customRole": "Incident Responder"
    }
  }'

const axios = require('axios');

const response = await axios({
  method: 'post',
  url: 'https://status200.ru/api/api-key-custom-role',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "data": {
      "apiKeyId": "e1f2a3b4-c5d6-4e7f-8a9b-0c1d2e3f4a5b",
      "customRoleId": "7a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d",
      "projectId": "a3f9c8e2-d4b6-4a7c-9e5f-1a2b3c4d5e6f",
      "apiKey": "Production API Key",
      "customRole": "Incident Responder"
    }
  }
});

console.log(response.data);

import axios, { AxiosResponse } from 'axios';

interface ApiResponse {
  // Define your response type here
  [key: string]: unknown;
}

const response: AxiosResponse<ApiResponse> = await axios({
  method: 'post',
  url: 'https://status200.ru/api/api-key-custom-role',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "data": {
      "apiKeyId": "e1f2a3b4-c5d6-4e7f-8a9b-0c1d2e3f4a5b",
      "customRoleId": "7a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d",
      "projectId": "a3f9c8e2-d4b6-4a7c-9e5f-1a2b3c4d5e6f",
      "apiKey": "Production API Key",
      "customRole": "Incident Responder"
    }
  }
});

console.log(response.data);

import requests

url = "https://status200.ru/api/api-key-custom-role"
headers = {
    "Content-Type": "application/json",
    "ApiKey": "YOUR_API_KEY"
}

payload = {
    "data": {
        "apiKeyId": "e1f2a3b4-c5d6-4e7f-8a9b-0c1d2e3f4a5b",
        "customRoleId": "7a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d",
        "projectId": "a3f9c8e2-d4b6-4a7c-9e5f-1a2b3c4d5e6f",
        "apiKey": "Production API Key",
        "customRole": "Incident Responder"
    }
}

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

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    payload := map[string]interface{}{
        "data": map[string]interface{}{"apiKeyId": "e1f2a3b4-c5d6-4e7f-8a9b-0c1d2e3f4a5b", "customRoleId": "7a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d", "projectId": "a3f9c8e2-d4b6-4a7c-9e5f-1a2b3c4d5e6f", "apiKey": "Production API Key", "customRole": "Incident Responder"},
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://status200.ru/api/api-key-custom-role", bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("ApiKey", "YOUR_API_KEY")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiRequest {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        String jsonBody = "{\n          \"data\": {\n                    \"apiKeyId\": \"e1f2a3b4-c5d6-4e7f-8a9b-0c1d2e3f4a5b\",\n                    \"customRoleId\": \"7a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d\",\n                    \"projectId\": \"a3f9c8e2-d4b6-4a7c-9e5f-1a2b3c4d5e6f\",\n                    \"apiKey\": \"Production API Key\",\n                    \"customRole\": \"Incident Responder\"\n          }\n}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://status200.ru/api/api-key-custom-role"))
            .header("Content-Type", "application/json")
            .header("ApiKey", "YOUR_API_KEY")
            .method("POST", HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();

        client.DefaultRequestHeaders.Add("ApiKey", "YOUR_API_KEY");

        var json = @"{
        ""data"": {
                ""apiKeyId"": ""e1f2a3b4-c5d6-4e7f-8a9b-0c1d2e3f4a5b"",
                ""customRoleId"": ""7a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d"",
                ""projectId"": ""a3f9c8e2-d4b6-4a7c-9e5f-1a2b3c4d5e6f"",
                ""apiKey"": ""Production API Key"",
                ""customRole"": ""Incident Responder""
        }
}";
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync(
            "https://status200.ru/api/api-key-custom-role", content);

        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}

<?php

$url = "https://status200.ru/api/api-key-custom-role";

$headers = [
    "Content-Type: application/json",
    "ApiKey: YOUR_API_KEY"
];

$data = [
    "data" => [
        "apiKeyId" => "e1f2a3b4-c5d6-4e7f-8a9b-0c1d2e3f4a5b",
        "customRoleId" => "7a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d",
        "projectId" => "a3f9c8e2-d4b6-4a7c-9e5f-1a2b3c4d5e6f",
        "apiKey" => "Production API Key",
        "customRole" => "Incident Responder"
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);
?>

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse("https://status200.ru/api/api-key-custom-role")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri.request_uri)
request["Content-Type"] = "application/json"
request["ApiKey"] = "YOUR_API_KEY"

request.body = {
  "data" => {
    "apiKeyId" => "e1f2a3b4-c5d6-4e7f-8a9b-0c1d2e3f4a5b",
    "customRoleId" => "7a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d",
    "projectId" => "a3f9c8e2-d4b6-4a7c-9e5f-1a2b3c4d5e6f",
    "apiKey" => "Production API Key",
    "customRole" => "Incident Responder"
  }
}.to_json

response = http.request(request)
puts JSON.parse(response.body)

use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    headers.insert("ApiKey", HeaderValue::from_static("YOUR_API_KEY"));

    let body = json!({
    "data": {
        "apiKeyId": "e1f2a3b4-c5d6-4e7f-8a9b-0c1d2e3f4a5b",
        "customRoleId": "7a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d",
        "projectId": "a3f9c8e2-d4b6-4a7c-9e5f-1a2b3c4d5e6f",
        "apiKey": "Production API Key",
        "customRole": "Incident Responder"
    }
});

    let response = client
        .post("https://status200.ru/api/api-key-custom-role")
        .headers(headers)
        .json(&body)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:#?}", result);

    Ok(())
}

$headers = @{
    "Content-Type" = "application/json"
    "ApiKey" = "YOUR_API_KEY"
}

$body = @{
    data = @{
        apiKeyId = "e1f2a3b4-c5d6-4e7f-8a9b-0c1d2e3f4a5b"
        customRoleId = "7a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d"
        projectId = "a3f9c8e2-d4b6-4a7c-9e5f-1a2b3c4d5e6f"
        apiKey = "Production API Key"
        customRole = "Incident Responder"
    }
} | ConvertTo-Json -Depth 10

$response = Invoke-RestMethod -Uri "https://status200.ru/api/api-key-custom-role" -Method POST -Headers $headers -Body $body
$response | ConvertTo-Json -Depth 10

curl -X PUT "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5" \
  -H "Content-Type: application/json" \
  -H "ApiKey: YOUR_API_KEY" \
  -d '{
    "data": {}
  }'

const axios = require('axios');

const response = await axios({
  method: 'put',
  url: 'https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "data": {}
  }
});

console.log(response.data);

import axios, { AxiosResponse } from 'axios';

interface ApiResponse {
  // Define your response type here
  [key: string]: unknown;
}

const response: AxiosResponse<ApiResponse> = await axios({
  method: 'put',
  url: 'https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "data": {}
  }
});

console.log(response.data);

import requests

url = "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5"
headers = {
    "Content-Type": "application/json",
    "ApiKey": "YOUR_API_KEY"
}

payload = {
    "data": {

    }
}

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

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    payload := map[string]interface{}{
        "data": map[string]interface{}{},
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("PUT", "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5", bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("ApiKey", "YOUR_API_KEY")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiRequest {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        String jsonBody = "{\n          \"data\": {}\n}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5"))
            .header("Content-Type", "application/json")
            .header("ApiKey", "YOUR_API_KEY")
            .method("PUT", HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();

        client.DefaultRequestHeaders.Add("ApiKey", "YOUR_API_KEY");

        var json = @"{
        ""data"": {}
}";
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PutAsync(
            "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5", content);

        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}

<?php

$url = "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5";

$headers = [
    "Content-Type: application/json",
    "ApiKey: YOUR_API_KEY"
];

$data = [
    "data" => [

    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);
?>

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse("https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Put.new(uri.request_uri)
request["Content-Type"] = "application/json"
request["ApiKey"] = "YOUR_API_KEY"

request.body = {
  "data" => {

  }
}.to_json

response = http.request(request)
puts JSON.parse(response.body)

use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    headers.insert("ApiKey", HeaderValue::from_static("YOUR_API_KEY"));

    let body = json!({
    "data": {

    }
});

    let response = client
        .put("https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5")
        .headers(headers)
        .json(&body)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:#?}", result);

    Ok(())
}

$headers = @{
    "Content-Type" = "application/json"
    "ApiKey" = "YOUR_API_KEY"
}

$body = @{
    data = @{

    }
} | ConvertTo-Json -Depth 10

$response = Invoke-RestMethod -Uri "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5" -Method PUT -Headers $headers -Body $body
$response | ConvertTo-Json -Depth 10

curl -X DELETE "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5" \
  -H "Content-Type: application/json" \
  -H "ApiKey: YOUR_API_KEY"

const axios = require('axios');

const response = await axios({
  method: 'delete',
  url: 'https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  }
});

console.log(response.data);

import axios, { AxiosResponse } from 'axios';

interface ApiResponse {
  // Define your response type here
  [key: string]: unknown;
}

const response: AxiosResponse<ApiResponse> = await axios({
  method: 'delete',
  url: 'https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  }
});

console.log(response.data);

import requests

url = "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5"
headers = {
    "Content-Type": "application/json",
    "ApiKey": "YOUR_API_KEY"
}

response = requests.delete(url, headers=headers)
print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("DELETE", "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5", nil)
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("ApiKey", "YOUR_API_KEY")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiRequest {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5"))
            .header("Content-Type", "application/json")
            .header("ApiKey", "YOUR_API_KEY")
            .method("DELETE", HttpRequest.BodyPublishers.noBody())
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();

        client.DefaultRequestHeaders.Add("ApiKey", "YOUR_API_KEY");

        var response = await client.DeleteAsync("https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5");

        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}

<?php

$url = "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5";

$headers = [
    "Content-Type: application/json",
    "ApiKey: YOUR_API_KEY"
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);
?>

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse("https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(uri.request_uri)
request["Content-Type"] = "application/json"
request["ApiKey"] = "YOUR_API_KEY"

response = http.request(request)
puts JSON.parse(response.body)

use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    headers.insert("ApiKey", HeaderValue::from_static("YOUR_API_KEY"));

    let response = client
        .delete("https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5")
        .headers(headers)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:#?}", result);

    Ok(())
}

$headers = @{
    "Content-Type" = "application/json"
    "ApiKey" = "YOUR_API_KEY"
}

$response = Invoke-RestMethod -Uri "https://status200.ru/api/api-key-custom-role/b0397794-7af6-4332-8078-931c2acdfab5" -Method DELETE -Headers $headers
$response | ConvertTo-Json -Depth 10