AI Rule

curl -X POST "https://status200.ru/api/auto-remediation-rule/get-list?skip=0&limit=10" \
  -H "Content-Type: application/json" \
  -H "ApiKey: YOUR_API_KEY" \
  -d '{
    "select": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": true,
      "openTelemetryPullRequests": true,
      "onlyIfOpenAfterMinutes": true
    },
    "query": {
      "executionMode": "Example execution mode"
    },
    "sort": {
      "createdAt": -1
    }
  }'

const axios = require('axios');

const response = await axios({
  method: 'post',
  url: 'https://status200.ru/api/auto-remediation-rule/get-list?skip=0&limit=10',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "select": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": true,
      "openTelemetryPullRequests": true,
      "onlyIfOpenAfterMinutes": true
    },
    "query": {
      "executionMode": "Example execution mode"
    },
    "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/auto-remediation-rule/get-list?skip=0&limit=10',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "select": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": true,
      "openTelemetryPullRequests": true,
      "onlyIfOpenAfterMinutes": true
    },
    "query": {
      "executionMode": "Example execution mode"
    },
    "sort": {
      "createdAt": -1
    }
  }
});

console.log(response.data);

import requests

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

payload = {
    "select": {
        "fixes": True,
        "investigates": True,
        "openCodeFixPullRequests": True,
        "openTelemetryPullRequests": True,
        "onlyIfOpenAfterMinutes": True
    },
    "query": {
        "executionMode": "Example execution mode"
    },
    "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{}{"fixes": true, "investigates": true, "openCodeFixPullRequests": true, "openTelemetryPullRequests": true, "onlyIfOpenAfterMinutes": true},
        "query": map[string]interface{}{"executionMode": "Example execution mode"},
        "sort": map[string]interface{}{"createdAt": -1},
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://status200.ru/api/auto-remediation-rule/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                    \"fixes\": true,\n                    \"investigates\": true,\n                    \"openCodeFixPullRequests\": true,\n                    \"openTelemetryPullRequests\": true,\n                    \"onlyIfOpenAfterMinutes\": true\n          },\n          \"query\": {\n                    \"executionMode\": \"Example execution mode\"\n          },\n          \"sort\": {\n                    \"createdAt\": -1\n          }\n}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://status200.ru/api/auto-remediation-rule/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"": {
                ""fixes"": true,
                ""investigates"": true,
                ""openCodeFixPullRequests"": true,
                ""openTelemetryPullRequests"": true,
                ""onlyIfOpenAfterMinutes"": true
        },
        ""query"": {
                ""executionMode"": ""Example execution mode""
        },
        ""sort"": {
                ""createdAt"": -1
        }
}";
        var content = new StringContent(json, Encoding.UTF8, "application/json");

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

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

<?php

$url = "https://status200.ru/api/auto-remediation-rule/get-list?skip=0&limit=10";

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

$data = [
    "select" => [
        "fixes" => true,
        "investigates" => true,
        "openCodeFixPullRequests" => true,
        "openTelemetryPullRequests" => true,
        "onlyIfOpenAfterMinutes" => true
    ],
    "query" => [
        "executionMode" => "Example execution mode"
    ],
    "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/auto-remediation-rule/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" => {
    "fixes" => true,
    "investigates" => true,
    "openCodeFixPullRequests" => true,
    "openTelemetryPullRequests" => true,
    "onlyIfOpenAfterMinutes" => true
  },
  "query" => {
    "executionMode" => "Example execution mode"
  },
  "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": {
        "fixes": true,
        "investigates": true,
        "openCodeFixPullRequests": true,
        "openTelemetryPullRequests": true,
        "onlyIfOpenAfterMinutes": true
    },
    "query": {
        "executionMode": "Example execution mode"
    },
    "sort": {
        "createdAt": -1
    }
});

    let response = client
        .post("https://status200.ru/api/auto-remediation-rule/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 = @{
        fixes = $true
        investigates = $true
        openCodeFixPullRequests = $true
        openTelemetryPullRequests = $true
        onlyIfOpenAfterMinutes = $true
    }
    query = @{
        executionMode = "Example execution mode"
    }
    sort = @{
        createdAt = -1
    }
} | ConvertTo-Json -Depth 10

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

curl -X POST "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764/get-item" \
  -H "Content-Type: application/json" \
  -H "ApiKey: YOUR_API_KEY" \
  -d '{
    "select": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": true,
      "openTelemetryPullRequests": true,
      "onlyIfOpenAfterMinutes": true
    }
  }'

const axios = require('axios');

const response = await axios({
  method: 'post',
  url: 'https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764/get-item',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "select": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": true,
      "openTelemetryPullRequests": true,
      "onlyIfOpenAfterMinutes": 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/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764/get-item',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "select": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": true,
      "openTelemetryPullRequests": true,
      "onlyIfOpenAfterMinutes": true
    }
  }
});

console.log(response.data);

import requests

url = "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764/get-item"
headers = {
    "Content-Type": "application/json",
    "ApiKey": "YOUR_API_KEY"
}

payload = {
    "select": {
        "fixes": True,
        "investigates": True,
        "openCodeFixPullRequests": True,
        "openTelemetryPullRequests": True,
        "onlyIfOpenAfterMinutes": 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{}{"fixes": true, "investigates": true, "openCodeFixPullRequests": true, "openTelemetryPullRequests": true, "onlyIfOpenAfterMinutes": true},
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764/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                    \"fixes\": true,\n                    \"investigates\": true,\n                    \"openCodeFixPullRequests\": true,\n                    \"openTelemetryPullRequests\": true,\n                    \"onlyIfOpenAfterMinutes\": true\n          }\n}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764/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"": {
                ""fixes"": true,
                ""investigates"": true,
                ""openCodeFixPullRequests"": true,
                ""openTelemetryPullRequests"": true,
                ""onlyIfOpenAfterMinutes"": true
        }
}";
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync(
            "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764/get-item", content);

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

<?php

$url = "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764/get-item";

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

$data = [
    "select" => [
        "fixes" => true,
        "investigates" => true,
        "openCodeFixPullRequests" => true,
        "openTelemetryPullRequests" => true,
        "onlyIfOpenAfterMinutes" => 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/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764/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" => {
    "fixes" => true,
    "investigates" => true,
    "openCodeFixPullRequests" => true,
    "openTelemetryPullRequests" => true,
    "onlyIfOpenAfterMinutes" => 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": {
        "fixes": true,
        "investigates": true,
        "openCodeFixPullRequests": true,
        "openTelemetryPullRequests": true,
        "onlyIfOpenAfterMinutes": true
    }
});

    let response = client
        .post("https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764/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 = @{
        fixes = $true
        investigates = $true
        openCodeFixPullRequests = $true
        openTelemetryPullRequests = $true
        onlyIfOpenAfterMinutes = $true
    }
} | ConvertTo-Json -Depth 10

$response = Invoke-RestMethod -Uri "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764/get-item" -Method POST -Headers $headers -Body $body
$response | ConvertTo-Json -Depth 10

curl -X POST "https://status200.ru/api/auto-remediation-rule/count" \
  -H "Content-Type: application/json" \
  -H "ApiKey: YOUR_API_KEY" \
  -d '{
    "query": {
      "executionMode": "Example execution mode"
    }
  }'

const axios = require('axios');

const response = await axios({
  method: 'post',
  url: 'https://status200.ru/api/auto-remediation-rule/count',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "query": {
      "executionMode": "Example execution mode"
    }
  }
});

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/auto-remediation-rule/count',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "query": {
      "executionMode": "Example execution mode"
    }
  }
});

console.log(response.data);

import requests

url = "https://status200.ru/api/auto-remediation-rule/count"
headers = {
    "Content-Type": "application/json",
    "ApiKey": "YOUR_API_KEY"
}

payload = {
    "query": {
        "executionMode": "Example execution mode"
    }
}

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{}{"executionMode": "Example execution mode"},
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://status200.ru/api/auto-remediation-rule/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                    \"executionMode\": \"Example execution mode\"\n          }\n}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://status200.ru/api/auto-remediation-rule/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"": {
                ""executionMode"": ""Example execution mode""
        }
}";
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync(
            "https://status200.ru/api/auto-remediation-rule/count", content);

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

<?php

$url = "https://status200.ru/api/auto-remediation-rule/count";

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

$data = [
    "query" => [
        "executionMode" => "Example execution mode"
    ]
];

$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/auto-remediation-rule/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" => {
    "executionMode" => "Example execution mode"
  }
}.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": {
        "executionMode": "Example execution mode"
    }
});

    let response = client
        .post("https://status200.ru/api/auto-remediation-rule/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 = @{
        executionMode = "Example execution mode"
    }
} | ConvertTo-Json -Depth 10

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

curl -X POST "https://status200.ru/api/auto-remediation-rule" \
  -H "Content-Type: application/json" \
  -H "ApiKey: YOUR_API_KEY" \
  -d '{
    "data": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": true,
      "openTelemetryPullRequests": true,
      "onlyIfOpenAfterMinutes": 10
    }
  }'

const axios = require('axios');

const response = await axios({
  method: 'post',
  url: 'https://status200.ru/api/auto-remediation-rule',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "data": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": true,
      "openTelemetryPullRequests": true,
      "onlyIfOpenAfterMinutes": 10
    }
  }
});

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/auto-remediation-rule',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "data": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": true,
      "openTelemetryPullRequests": true,
      "onlyIfOpenAfterMinutes": 10
    }
  }
});

console.log(response.data);

import requests

url = "https://status200.ru/api/auto-remediation-rule"
headers = {
    "Content-Type": "application/json",
    "ApiKey": "YOUR_API_KEY"
}

payload = {
    "data": {
        "fixes": True,
        "investigates": True,
        "openCodeFixPullRequests": True,
        "openTelemetryPullRequests": True,
        "onlyIfOpenAfterMinutes": 10
    }
}

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{}{"fixes": true, "investigates": true, "openCodeFixPullRequests": true, "openTelemetryPullRequests": true, "onlyIfOpenAfterMinutes": 10},
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://status200.ru/api/auto-remediation-rule", 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                    \"fixes\": true,\n                    \"investigates\": true,\n                    \"openCodeFixPullRequests\": true,\n                    \"openTelemetryPullRequests\": true,\n                    \"onlyIfOpenAfterMinutes\": 10\n          }\n}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://status200.ru/api/auto-remediation-rule"))
            .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"": {
                ""fixes"": true,
                ""investigates"": true,
                ""openCodeFixPullRequests"": true,
                ""openTelemetryPullRequests"": true,
                ""onlyIfOpenAfterMinutes"": 10
        }
}";
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync(
            "https://status200.ru/api/auto-remediation-rule", content);

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

<?php

$url = "https://status200.ru/api/auto-remediation-rule";

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

$data = [
    "data" => [
        "fixes" => true,
        "investigates" => true,
        "openCodeFixPullRequests" => true,
        "openTelemetryPullRequests" => true,
        "onlyIfOpenAfterMinutes" => 10
    ]
];

$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/auto-remediation-rule")
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" => {
    "fixes" => true,
    "investigates" => true,
    "openCodeFixPullRequests" => true,
    "openTelemetryPullRequests" => true,
    "onlyIfOpenAfterMinutes" => 10
  }
}.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": {
        "fixes": true,
        "investigates": true,
        "openCodeFixPullRequests": true,
        "openTelemetryPullRequests": true,
        "onlyIfOpenAfterMinutes": 10
    }
});

    let response = client
        .post("https://status200.ru/api/auto-remediation-rule")
        .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 = @{
        fixes = $true
        investigates = $true
        openCodeFixPullRequests = $true
        openTelemetryPullRequests = $true
        onlyIfOpenAfterMinutes = 10
    }
} | ConvertTo-Json -Depth 10

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

curl -X PUT "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764" \
  -H "Content-Type: application/json" \
  -H "ApiKey: YOUR_API_KEY" \
  -d '{
    "data": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": true
    }
  }'

const axios = require('axios');

const response = await axios({
  method: 'put',
  url: 'https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "data": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": 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: 'put',
  url: 'https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  },
  data: {
    "data": {
      "fixes": true,
      "investigates": true,
      "openCodeFixPullRequests": true
    }
  }
});

console.log(response.data);

import requests

url = "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764"
headers = {
    "Content-Type": "application/json",
    "ApiKey": "YOUR_API_KEY"
}

payload = {
    "data": {
        "fixes": True,
        "investigates": True,
        "openCodeFixPullRequests": True
    }
}

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{}{"fixes": true, "investigates": true, "openCodeFixPullRequests": true},
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("PUT", "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764", 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                    \"fixes\": true,\n                    \"investigates\": true,\n                    \"openCodeFixPullRequests\": true\n          }\n}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764"))
            .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"": {
                ""fixes"": true,
                ""investigates"": true,
                ""openCodeFixPullRequests"": true
        }
}";
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PutAsync(
            "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764", content);

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

<?php

$url = "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764";

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

$data = [
    "data" => [
        "fixes" => true,
        "investigates" => true,
        "openCodeFixPullRequests" => true
    ]
];

$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/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764")
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" => {
    "fixes" => true,
    "investigates" => true,
    "openCodeFixPullRequests" => 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!({
    "data": {
        "fixes": true,
        "investigates": true,
        "openCodeFixPullRequests": true
    }
});

    let response = client
        .put("https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764")
        .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 = @{
        fixes = $true
        investigates = $true
        openCodeFixPullRequests = $true
    }
} | ConvertTo-Json -Depth 10

$response = Invoke-RestMethod -Uri "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764" -Method PUT -Headers $headers -Body $body
$response | ConvertTo-Json -Depth 10

curl -X DELETE "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764" \
  -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/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764',
  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/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764',
  headers: {
    'Content-Type': 'application/json',
    'ApiKey': 'YOUR_API_KEY'
  }
});

console.log(response.data);

import requests

url = "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764"
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/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764", 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/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764"))
            .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/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764");

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

<?php

$url = "https://status200.ru/api/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764";

$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/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764")
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/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764")
        .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/auto-remediation-rule/b67b51cd-c925-407a-9a4e-ed3663d93764" -Method DELETE -Headers $headers
$response | ConvertTo-Json -Depth 10