---
title: Dokploy API
description: Endpoints for dokploy
full: true
---

import { Root, API, APIInfo, APIExample, Responses, Response, ResponseTypes, ExampleResponse, TypeScriptResponse, Property, ObjectCollapsible, Requests, Request } from "fumadocs-ui/components/api";

<Root>

<API>

<APIInfo method={"GET"} route={"/admin.one"}>

## admin-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/admin.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/admin.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/admin.createUserInvitation"}>

## admin-createUserInvitation

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"email"} type={"string"} required={true} deprecated={undefined}>

<span>Format:  `"email"`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/admin.createUserInvitation" \
  -d '{
  "email": "user@example.com"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/admin.createUserInvitation", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/admin.removeUser"}>

## admin-removeUser

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"authId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/admin.removeUser" \
  -d '{
  "authId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/admin.removeUser", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/admin.getUserByToken"}>

## admin-getUserByToken

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"token"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/admin.getUserByToken"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/admin.getUserByToken", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/admin.assignPermissions"}>

## admin-assignPermissions

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"userId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"canCreateProjects"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

<Property name={"canCreateServices"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

<Property name={"canDeleteProjects"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

<Property name={"canDeleteServices"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

<Property name={"accesedProjects"} type={"array of string"} required={true} deprecated={undefined}>

</Property>

<Property name={"accesedServices"} type={"array of string"} required={true} deprecated={undefined}>

</Property>

<Property name={"canAccessToTraefikFiles"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

<Property name={"canAccessToDocker"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

<Property name={"canAccessToAPI"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/admin.assignPermissions" \
  -d '{
  "userId": "string",
  "canCreateProjects": true,
  "canCreateServices": true,
  "canDeleteProjects": true,
  "canDeleteServices": true,
  "accesedProjects": [
    "string"
  ],
  "accesedServices": [
    "string"
  ],
  "canAccessToTraefikFiles": true,
  "canAccessToDocker": true,
  "canAccessToAPI": true
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/admin.assignPermissions", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/admin.cleanGithubApp"}>

## admin-cleanGithubApp

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/admin.cleanGithubApp"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/admin.cleanGithubApp", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/admin.getRepositories"}>

## admin-getRepositories

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/admin.getRepositories"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/admin.getRepositories", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/admin.getBranches"}>

## admin-getBranches

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"repo"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"owner"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/admin.getBranches"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/admin.getBranches", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/admin.haveGithubConfigured"}>

## admin-haveGithubConfigured

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/admin.haveGithubConfigured"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/admin.haveGithubConfigured", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/docker.getContainers"}>

## docker-getContainers

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/docker.getContainers"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/docker.getContainers", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/docker.getConfig"}>

## docker-getConfig

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"containerId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/docker.getConfig"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/docker.getConfig", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/docker.getContainersByAppNameMatch"}>

## docker-getContainersByAppNameMatch

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"appName"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/docker.getContainersByAppNameMatch"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/docker.getContainersByAppNameMatch", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/docker.getContainersByAppLabel"}>

## docker-getContainersByAppLabel

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"appName"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/docker.getContainersByAppLabel"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/docker.getContainersByAppLabel", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/auth.createAdmin"}>

## auth-createAdmin

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"email"} type={"string"} required={true} deprecated={undefined}>

<span>Format:  `"email"`</span>

</Property>

<Property name={"password"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `8`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/auth.createAdmin" \
  -d '{
  "email": "user@example.com",
  "password": "stringst"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.createAdmin", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/auth.createUser"}>

## auth-createUser

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"password"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `8`</span>

</Property>

<Property name={"id"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"token"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/auth.createUser" \
  -d '{
  "password": "stringst",
  "id": "string",
  "token": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.createUser", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/auth.login"}>

## auth-login

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"email"} type={"string"} required={true} deprecated={undefined}>

<span>Format:  `"email"`</span>

</Property>

<Property name={"password"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `8`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/auth.login" \
  -d '{
  "email": "user@example.com",
  "password": "stringst"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.login", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/auth.get"}>

## auth-get

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/auth.get"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.get", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/auth.logout"}>

## auth-logout

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/auth.logout"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.logout", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/auth.update"}>

## auth-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"id"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"email"} type={"string | null"} required={true} deprecated={undefined}>

</Property>

<Property name={"password"} type={"string | null"} required={true} deprecated={undefined}>

</Property>

<Property name={"rol"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"admin" | "user"`</span>

</Property>

<Property name={"image"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"secret"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"token"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"is2FAEnabled"} type={"boolean"} required={false} deprecated={undefined}>

</Property>

<Property name={"createdAt"} type={"string"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/auth.update" \
  -d '{
  "id": "string",
  "email": "string",
  "password": "string",
  "rol": "admin",
  "image": "string",
  "secret": "string",
  "token": "string",
  "is2FAEnabled": true,
  "createdAt": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/auth.generateToken"}>

## auth-generateToken

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/auth.generateToken"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.generateToken", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/auth.one"}>

## auth-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"id"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/auth.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/auth.updateByAdmin"}>

## auth-updateByAdmin

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"id"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"email"} type={"string | null"} required={true} deprecated={undefined}>

</Property>

<Property name={"password"} type={"string | null"} required={true} deprecated={undefined}>

</Property>

<Property name={"rol"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"admin" | "user"`</span>

</Property>

<Property name={"image"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"secret"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"token"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"is2FAEnabled"} type={"boolean"} required={false} deprecated={undefined}>

</Property>

<Property name={"createdAt"} type={"string"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/auth.updateByAdmin" \
  -d '{
  "id": "string",
  "email": "string",
  "password": "string",
  "rol": "admin",
  "image": "string",
  "secret": "string",
  "token": "string",
  "is2FAEnabled": true,
  "createdAt": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.updateByAdmin", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/auth.generate2FASecret"}>

## auth-generate2FASecret

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/auth.generate2FASecret"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.generate2FASecret", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/auth.verify2FASetup"}>

## auth-verify2FASetup

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"pin"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `6`</span>

</Property>

<Property name={"secret"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/auth.verify2FASetup" \
  -d '{
  "pin": "string",
  "secret": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.verify2FASetup", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/auth.verifyLogin2FA"}>

## auth-verifyLogin2FA

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"pin"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `6`</span>

</Property>

<Property name={"id"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/auth.verifyLogin2FA" \
  -d '{
  "pin": "string",
  "id": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.verifyLogin2FA", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/auth.disable2FA"}>

## auth-disable2FA

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/auth.disable2FA"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.disable2FA", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/auth.verifyToken"}>

## auth-verifyToken

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/auth.verifyToken"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/auth.verifyToken", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/project.create"}>

## project-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/project.create" \
  -d '{
  "name": "string",
  "description": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/project.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/project.one"}>

## project-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"projectId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/project.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/project.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/project.all"}>

## project-all

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/project.all"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/project.all", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/project.remove"}>

## project-remove

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"projectId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/project.remove" \
  -d '{
  "projectId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/project.remove", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/project.update"}>

## project-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"projectId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/project.update" \
  -d '{
  "name": "string",
  "description": "string",
  "projectId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/project.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.create"}>

## application-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"projectId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.create" \
  -d '{
  "name": "string",
  "appName": "string",
  "description": "string",
  "projectId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/application.one"}>

## application-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"applicationId"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/application.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.reload"}>

## application-reload

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"appName"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.reload" \
  -d '{
  "appName": "string",
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.reload", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.delete"}>

## application-delete

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.delete" \
  -d '{
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.delete", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.stop"}>

## application-stop

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.stop" \
  -d '{
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.stop", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.start"}>

## application-start

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.start" \
  -d '{
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.start", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.redeploy"}>

## application-redeploy

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.redeploy" \
  -d '{
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.redeploy", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.saveEnvironment"}>

## application-saveEnvironment

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.saveEnvironment" \
  -d '{
  "applicationId": "string",
  "env": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.saveEnvironment", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.saveBuildType"}>

## application-saveBuildType

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"buildType"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"dockerfile" | "heroku_buildpacks" | "paketo_buildpacks" | "nixpacks"`</span>

</Property>

<Property name={"dockerfile"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.saveBuildType" \
  -d '{
  "applicationId": "string",
  "buildType": "dockerfile",
  "dockerfile": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.saveBuildType", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.saveGithubProvider"}>

## application-saveGithubProvider

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"repository"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"branch"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"owner"} type={"string | null"} required={true} deprecated={undefined}>

</Property>

<Property name={"buildPath"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.saveGithubProvider" \
  -d '{
  "applicationId": "string",
  "repository": "string",
  "branch": "string",
  "owner": "string",
  "buildPath": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.saveGithubProvider", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.saveDockerProvider"}>

## application-saveDockerProvider

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"dockerImage"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"username"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"password"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.saveDockerProvider" \
  -d '{
  "dockerImage": "string",
  "applicationId": "string",
  "username": "string",
  "password": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.saveDockerProvider", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.saveGitProdiver"}>

## application-saveGitProdiver

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"customGitBranch"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"customGitBuildPath"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"customGitUrl"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.saveGitProdiver" \
  -d '{
  "customGitBranch": "string",
  "applicationId": "string",
  "customGitBuildPath": "string",
  "customGitUrl": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.saveGitProdiver", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.generateSSHKey"}>

## application-generateSSHKey

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.generateSSHKey" \
  -d '{
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.generateSSHKey", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.removeSSHKey"}>

## application-removeSSHKey

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.removeSSHKey" \
  -d '{
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.removeSSHKey", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.markRunning"}>

## application-markRunning

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.markRunning" \
  -d '{
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.markRunning", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.update"}>

## application-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"name"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"title"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"enabled"} type={"boolean | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"subtitle"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"command"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"refreshToken"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"sourceType"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"github" | "docker" | "git"`</span>

</Property>

<Property name={"repository"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"owner"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"branch"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"buildPath"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"autoDeploy"} type={"boolean | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"username"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"password"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"dockerImage"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"customGitUrl"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"customGitBranch"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"customGitBuildPath"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"customGitSSHKey"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"dockerfile"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"healthCheckSwarm"} type={"object | null"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"healthCheckSwarm"}>

<Property name={"Test"} type={"array of string"} required={false} deprecated={undefined}>

</Property>

<Property name={"Interval"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"Timeout"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"StartPeriod"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"Retries"} type={"number"} required={false} deprecated={undefined}>

</Property>

</ObjectCollapsible>

</Property>

<Property name={"restartPolicySwarm"} type={"object | null"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"restartPolicySwarm"}>

<Property name={"Condition"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"Delay"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"MaxAttempts"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"Window"} type={"number"} required={false} deprecated={undefined}>

</Property>

</ObjectCollapsible>

</Property>

<Property name={"placementSwarm"} type={"object | null"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"placementSwarm"}>

<Property name={"Constraints"} type={"array of string"} required={false} deprecated={undefined}>

</Property>

<Property name={"Preferences"} type={"array of object"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"Preferences"}>

<Property name={"Spread"} type={"object"} required={true} deprecated={undefined}>

<ObjectCollapsible name={"Spread"}>

<Property name={"SpreadDescriptor"} type={"string"} required={true} deprecated={undefined}>

</Property>

</ObjectCollapsible>

</Property>

</ObjectCollapsible>

</Property>

<Property name={"MaxReplicas"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"Platforms"} type={"array of object"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"Platforms"}>

<Property name={"Architecture"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"OS"} type={"string"} required={true} deprecated={undefined}>

</Property>

</ObjectCollapsible>

</Property>

</ObjectCollapsible>

</Property>

<Property name={"updateConfigSwarm"} type={"object | null"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"updateConfigSwarm"}>

<Property name={"Parallelism"} type={"number"} required={true} deprecated={undefined}>

</Property>

<Property name={"Delay"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"FailureAction"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"Monitor"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"MaxFailureRatio"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"Order"} type={"string"} required={true} deprecated={undefined}>

</Property>

</ObjectCollapsible>

</Property>

<Property name={"rollbackConfigSwarm"} type={"object | null"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"rollbackConfigSwarm"}>

<Property name={"Parallelism"} type={"number"} required={true} deprecated={undefined}>

</Property>

<Property name={"Delay"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"FailureAction"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"Monitor"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"MaxFailureRatio"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"Order"} type={"string"} required={true} deprecated={undefined}>

</Property>

</ObjectCollapsible>

</Property>

<Property name={"modeSwarm"} type={"object | null"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"modeSwarm"}>

<Property name={"Replicated"} type={"object"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"Replicated"}>

<Property name={"Replicas"} type={"number"} required={false} deprecated={undefined}>

</Property>

</ObjectCollapsible>

</Property>

<Property name={"Global"} type={"object"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"Global"}>

</ObjectCollapsible>

</Property>

<Property name={"ReplicatedJob"} type={"object"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"ReplicatedJob"}>

<Property name={"MaxConcurrent"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"TotalCompletions"} type={"number"} required={false} deprecated={undefined}>

</Property>

</ObjectCollapsible>

</Property>

<Property name={"GlobalJob"} type={"object"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"GlobalJob"}>

</ObjectCollapsible>

</Property>

</ObjectCollapsible>

</Property>

<Property name={"labelsSwarm"} type={"object | null"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"labelsSwarm"}>

<Property name={"[key: string]"} type={"string"} required={false} deprecated={undefined}>

</Property>

</ObjectCollapsible>

</Property>

<Property name={"networkSwarm"} type={"array of object | null"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"networkSwarm"}>

<Property name={"Target"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"Aliases"} type={"array of string"} required={false} deprecated={undefined}>

</Property>

<Property name={"DriverOpts"} type={"object"} required={false} deprecated={undefined}>

<ObjectCollapsible name={"DriverOpts"}>

</ObjectCollapsible>

</Property>

</ObjectCollapsible>

</Property>

<Property name={"replicas"} type={"number"} required={false} deprecated={undefined}>

</Property>

<Property name={"applicationStatus"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

<Property name={"buildType"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"dockerfile" | "heroku_buildpacks" | "paketo_buildpacks" | "nixpacks"`</span>

</Property>

<Property name={"createdAt"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"registryId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"projectId"} type={"string"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.update" \
  -d '{
  "applicationId": "string",
  "name": "string",
  "appName": "string",
  "description": "string",
  "env": "string",
  "memoryReservation": 0,
  "memoryLimit": 0,
  "cpuReservation": 0,
  "cpuLimit": 0,
  "title": "string",
  "enabled": true,
  "subtitle": "string",
  "command": "string",
  "refreshToken": "string",
  "sourceType": "github",
  "repository": "string",
  "owner": "string",
  "branch": "string",
  "buildPath": "string",
  "autoDeploy": true,
  "username": "string",
  "password": "string",
  "dockerImage": "string",
  "customGitUrl": "string",
  "customGitBranch": "string",
  "customGitBuildPath": "string",
  "customGitSSHKey": "string",
  "dockerfile": "string",
  "healthCheckSwarm": {
    "Test": [
      "string"
    ],
    "Interval": 0,
    "Timeout": 0,
    "StartPeriod": 0,
    "Retries": 0
  },
  "restartPolicySwarm": {
    "Condition": "string",
    "Delay": 0,
    "MaxAttempts": 0,
    "Window": 0
  },
  "placementSwarm": {
    "Constraints": [
      "string"
    ],
    "Preferences": [
      {
        "Spread": {
          "SpreadDescriptor": "string"
        }
      }
    ],
    "MaxReplicas": 0,
    "Platforms": [
      {
        "Architecture": "string",
        "OS": "string"
      }
    ]
  },
  "updateConfigSwarm": {
    "Parallelism": 0,
    "Delay": 0,
    "FailureAction": "string",
    "Monitor": 0,
    "MaxFailureRatio": 0,
    "Order": "string"
  },
  "rollbackConfigSwarm": {
    "Parallelism": 0,
    "Delay": 0,
    "FailureAction": "string",
    "Monitor": 0,
    "MaxFailureRatio": 0,
    "Order": "string"
  },
  "modeSwarm": {
    "Replicated": {
      "Replicas": 0
    },
    "Global": {},
    "ReplicatedJob": {
      "MaxConcurrent": 0,
      "TotalCompletions": 0
    },
    "GlobalJob": {}
  },
  "labelsSwarm": {
    "property1": "string",
    "property2": "string"
  },
  "networkSwarm": [
    {
      "Target": "string",
      "Aliases": [
        "string"
      ],
      "DriverOpts": {}
    }
  ],
  "replicas": 0,
  "applicationStatus": "idle",
  "buildType": "dockerfile",
  "createdAt": "string",
  "registryId": "string",
  "projectId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.refreshToken"}>

## application-refreshToken

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.refreshToken" \
  -d '{
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.refreshToken", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.deploy"}>

## application-deploy

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.deploy" \
  -d '{
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.deploy", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.cleanQueues"}>

## application-cleanQueues

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.cleanQueues" \
  -d '{
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.cleanQueues", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/application.readTraefikConfig"}>

## application-readTraefikConfig

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"applicationId"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/application.readTraefikConfig"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.readTraefikConfig", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/application.updateTraefikConfig"}>

## application-updateTraefikConfig

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"traefikConfig"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/application.updateTraefikConfig" \
  -d '{
  "applicationId": "string",
  "traefikConfig": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.updateTraefikConfig", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/application.readAppMonitoring"}>

## application-readAppMonitoring

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"appName"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/application.readAppMonitoring"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/application.readAppMonitoring", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mysql.create"}>

## mysql-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"dockerImage"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"mysql:8"`</span>

</Property>

<Property name={"projectId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"databaseName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databaseUser"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databasePassword"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"databaseRootPassword"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mysql.create" \
  -d '{
  "name": "string",
  "appName": "string",
  "dockerImage": "mysql:8",
  "projectId": "string",
  "description": "string",
  "databaseName": "string",
  "databaseUser": "string",
  "databasePassword": "string",
  "databaseRootPassword": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mysql.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/mysql.one"}>

## mysql-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"mysqlId"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/mysql.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mysql.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mysql.start"}>

## mysql-start

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mysqlId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mysql.start" \
  -d '{
  "mysqlId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mysql.start", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mysql.stop"}>

## mysql-stop

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mysqlId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mysql.stop" \
  -d '{
  "mysqlId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mysql.stop", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mysql.saveExternalPort"}>

## mysql-saveExternalPort

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mysqlId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"externalPort"} type={"number | null"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mysql.saveExternalPort" \
  -d '{
  "mysqlId": "string",
  "externalPort": 0
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mysql.saveExternalPort", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mysql.deploy"}>

## mysql-deploy

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mysqlId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mysql.deploy" \
  -d '{
  "mysqlId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mysql.deploy", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mysql.changeStatus"}>

## mysql-changeStatus

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mysqlId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"applicationStatus"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mysql.changeStatus" \
  -d '{
  "mysqlId": "string",
  "applicationStatus": "idle"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mysql.changeStatus", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mysql.reload"}>

## mysql-reload

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mysqlId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"appName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mysql.reload" \
  -d '{
  "mysqlId": "string",
  "appName": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mysql.reload", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mysql.remove"}>

## mysql-remove

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mysqlId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mysql.remove" \
  -d '{
  "mysqlId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mysql.remove", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mysql.saveEnvironment"}>

## mysql-saveEnvironment

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mysqlId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mysql.saveEnvironment" \
  -d '{
  "mysqlId": "string",
  "env": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mysql.saveEnvironment", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mysql.update"}>

## mysql-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mysqlId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"name"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"databaseName"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databaseUser"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databasePassword"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"databaseRootPassword"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"dockerImage"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"mysql:8"`</span>

</Property>

<Property name={"command"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"externalPort"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"applicationStatus"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

<Property name={"createdAt"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"projectId"} type={"string"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mysql.update" \
  -d '{
  "mysqlId": "string",
  "name": "string",
  "appName": "string",
  "description": "string",
  "databaseName": "string",
  "databaseUser": "string",
  "databasePassword": "string",
  "databaseRootPassword": "string",
  "dockerImage": "mysql:8",
  "command": "string",
  "env": "string",
  "memoryReservation": 0,
  "memoryLimit": 0,
  "cpuReservation": 0,
  "cpuLimit": 0,
  "externalPort": 0,
  "applicationStatus": "idle",
  "createdAt": "string",
  "projectId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mysql.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/postgres.create"}>

## postgres-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"databaseName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databaseUser"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databasePassword"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"dockerImage"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"postgres:15"`</span>

</Property>

<Property name={"projectId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/postgres.create" \
  -d '{
  "name": "string",
  "appName": "string",
  "databaseName": "string",
  "databaseUser": "string",
  "databasePassword": "string",
  "dockerImage": "postgres:15",
  "projectId": "string",
  "description": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/postgres.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/postgres.one"}>

## postgres-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"postgresId"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/postgres.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/postgres.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/postgres.start"}>

## postgres-start

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"postgresId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/postgres.start" \
  -d '{
  "postgresId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/postgres.start", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/postgres.stop"}>

## postgres-stop

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"postgresId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/postgres.stop" \
  -d '{
  "postgresId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/postgres.stop", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/postgres.saveExternalPort"}>

## postgres-saveExternalPort

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"postgresId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"externalPort"} type={"number | null"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/postgres.saveExternalPort" \
  -d '{
  "postgresId": "string",
  "externalPort": 0
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/postgres.saveExternalPort", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/postgres.deploy"}>

## postgres-deploy

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"postgresId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/postgres.deploy" \
  -d '{
  "postgresId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/postgres.deploy", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/postgres.changeStatus"}>

## postgres-changeStatus

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"postgresId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"applicationStatus"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/postgres.changeStatus" \
  -d '{
  "postgresId": "string",
  "applicationStatus": "idle"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/postgres.changeStatus", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/postgres.remove"}>

## postgres-remove

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"postgresId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/postgres.remove" \
  -d '{
  "postgresId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/postgres.remove", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/postgres.saveEnvironment"}>

## postgres-saveEnvironment

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"postgresId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/postgres.saveEnvironment" \
  -d '{
  "postgresId": "string",
  "env": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/postgres.saveEnvironment", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/postgres.reload"}>

## postgres-reload

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"postgresId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"appName"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/postgres.reload" \
  -d '{
  "postgresId": "string",
  "appName": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/postgres.reload", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/postgres.update"}>

## postgres-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"postgresId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"name"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"databaseName"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databaseUser"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databasePassword"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"dockerImage"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"postgres:15"`</span>

</Property>

<Property name={"command"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"externalPort"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"applicationStatus"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

<Property name={"createdAt"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"projectId"} type={"string"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/postgres.update" \
  -d '{
  "postgresId": "string",
  "name": "string",
  "appName": "string",
  "databaseName": "string",
  "databaseUser": "string",
  "databasePassword": "string",
  "description": "string",
  "dockerImage": "postgres:15",
  "command": "string",
  "env": "string",
  "memoryReservation": 0,
  "externalPort": 0,
  "memoryLimit": 0,
  "cpuReservation": 0,
  "cpuLimit": 0,
  "applicationStatus": "idle",
  "createdAt": "string",
  "projectId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/postgres.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redis.create"}>

## redis-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databasePassword"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"dockerImage"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"redis:8"`</span>

</Property>

<Property name={"projectId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redis.create" \
  -d '{
  "name": "string",
  "appName": "string",
  "databasePassword": "string",
  "dockerImage": "redis:8",
  "projectId": "string",
  "description": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redis.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/redis.one"}>

## redis-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"redisId"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/redis.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redis.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redis.start"}>

## redis-start

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"redisId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redis.start" \
  -d '{
  "redisId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redis.start", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redis.reload"}>

## redis-reload

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"redisId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"appName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redis.reload" \
  -d '{
  "redisId": "string",
  "appName": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redis.reload", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redis.stop"}>

## redis-stop

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"redisId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redis.stop" \
  -d '{
  "redisId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redis.stop", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redis.saveExternalPort"}>

## redis-saveExternalPort

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"redisId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"externalPort"} type={"number | null"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redis.saveExternalPort" \
  -d '{
  "redisId": "string",
  "externalPort": 0
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redis.saveExternalPort", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redis.deploy"}>

## redis-deploy

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"redisId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redis.deploy" \
  -d '{
  "redisId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redis.deploy", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redis.changeStatus"}>

## redis-changeStatus

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"redisId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"applicationStatus"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redis.changeStatus" \
  -d '{
  "redisId": "string",
  "applicationStatus": "idle"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redis.changeStatus", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redis.remove"}>

## redis-remove

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"redisId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redis.remove" \
  -d '{
  "redisId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redis.remove", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redis.saveEnvironment"}>

## redis-saveEnvironment

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"redisId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redis.saveEnvironment" \
  -d '{
  "redisId": "string",
  "env": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redis.saveEnvironment", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redis.update"}>

## redis-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"redisId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"name"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"databasePassword"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"dockerImage"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"redis:8"`</span>

</Property>

<Property name={"command"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"externalPort"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"createdAt"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"applicationStatus"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

<Property name={"projectId"} type={"string"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redis.update" \
  -d '{
  "redisId": "string",
  "name": "string",
  "appName": "string",
  "description": "string",
  "databasePassword": "string",
  "dockerImage": "redis:8",
  "command": "string",
  "env": "string",
  "memoryReservation": 0,
  "memoryLimit": 0,
  "cpuReservation": 0,
  "cpuLimit": 0,
  "externalPort": 0,
  "createdAt": "string",
  "applicationStatus": "idle",
  "projectId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redis.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mongo.create"}>

## mongo-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"dockerImage"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"mongo:15"`</span>

</Property>

<Property name={"projectId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"databaseUser"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databasePassword"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mongo.create" \
  -d '{
  "name": "string",
  "appName": "string",
  "dockerImage": "mongo:15",
  "projectId": "string",
  "description": "string",
  "databaseUser": "string",
  "databasePassword": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mongo.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/mongo.one"}>

## mongo-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"mongoId"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/mongo.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mongo.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mongo.start"}>

## mongo-start

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mongoId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mongo.start" \
  -d '{
  "mongoId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mongo.start", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mongo.stop"}>

## mongo-stop

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mongoId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mongo.stop" \
  -d '{
  "mongoId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mongo.stop", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mongo.saveExternalPort"}>

## mongo-saveExternalPort

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mongoId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"externalPort"} type={"number | null"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mongo.saveExternalPort" \
  -d '{
  "mongoId": "string",
  "externalPort": 0
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mongo.saveExternalPort", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mongo.deploy"}>

## mongo-deploy

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mongoId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mongo.deploy" \
  -d '{
  "mongoId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mongo.deploy", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mongo.changeStatus"}>

## mongo-changeStatus

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mongoId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"applicationStatus"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mongo.changeStatus" \
  -d '{
  "mongoId": "string",
  "applicationStatus": "idle"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mongo.changeStatus", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mongo.reload"}>

## mongo-reload

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mongoId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"appName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mongo.reload" \
  -d '{
  "mongoId": "string",
  "appName": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mongo.reload", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mongo.remove"}>

## mongo-remove

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mongoId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mongo.remove" \
  -d '{
  "mongoId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mongo.remove", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mongo.saveEnvironment"}>

## mongo-saveEnvironment

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mongoId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mongo.saveEnvironment" \
  -d '{
  "mongoId": "string",
  "env": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mongo.saveEnvironment", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mongo.update"}>

## mongo-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mongoId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"name"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"databaseUser"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databasePassword"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"dockerImage"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"mongo:15"`</span>

</Property>

<Property name={"command"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"externalPort"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"applicationStatus"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

<Property name={"createdAt"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"projectId"} type={"string"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mongo.update" \
  -d '{
  "mongoId": "string",
  "name": "string",
  "appName": "string",
  "description": "string",
  "databaseUser": "string",
  "databasePassword": "string",
  "dockerImage": "mongo:15",
  "command": "string",
  "env": "string",
  "memoryReservation": 0,
  "memoryLimit": 0,
  "cpuReservation": 0,
  "cpuLimit": 0,
  "externalPort": 0,
  "applicationStatus": "idle",
  "createdAt": "string",
  "projectId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mongo.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mariadb.create"}>

## mariadb-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"dockerImage"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"mariadb:6"`</span>

</Property>

<Property name={"databaseRootPassword"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"projectId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"databaseName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databaseUser"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databasePassword"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mariadb.create" \
  -d '{
  "name": "string",
  "appName": "string",
  "dockerImage": "mariadb:6",
  "databaseRootPassword": "string",
  "projectId": "string",
  "description": "string",
  "databaseName": "string",
  "databaseUser": "string",
  "databasePassword": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mariadb.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/mariadb.one"}>

## mariadb-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"mariadbId"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/mariadb.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mariadb.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mariadb.start"}>

## mariadb-start

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mariadbId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mariadb.start" \
  -d '{
  "mariadbId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mariadb.start", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mariadb.stop"}>

## mariadb-stop

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mariadbId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mariadb.stop" \
  -d '{
  "mariadbId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mariadb.stop", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mariadb.saveExternalPort"}>

## mariadb-saveExternalPort

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mariadbId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"externalPort"} type={"number | null"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mariadb.saveExternalPort" \
  -d '{
  "mariadbId": "string",
  "externalPort": 0
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mariadb.saveExternalPort", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mariadb.deploy"}>

## mariadb-deploy

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mariadbId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mariadb.deploy" \
  -d '{
  "mariadbId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mariadb.deploy", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mariadb.changeStatus"}>

## mariadb-changeStatus

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mariadbId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"applicationStatus"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mariadb.changeStatus" \
  -d '{
  "mariadbId": "string",
  "applicationStatus": "idle"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mariadb.changeStatus", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mariadb.remove"}>

## mariadb-remove

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mariadbId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mariadb.remove" \
  -d '{
  "mariadbId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mariadb.remove", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mariadb.saveEnvironment"}>

## mariadb-saveEnvironment

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mariadbId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mariadb.saveEnvironment" \
  -d '{
  "mariadbId": "string",
  "env": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mariadb.saveEnvironment", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mariadb.reload"}>

## mariadb-reload

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mariadbId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"appName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mariadb.reload" \
  -d '{
  "mariadbId": "string",
  "appName": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mariadb.reload", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mariadb.update"}>

## mariadb-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mariadbId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"name"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"databaseName"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databaseUser"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"databasePassword"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"databaseRootPassword"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"dockerImage"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"mariadb:6"`</span>

</Property>

<Property name={"command"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"memoryLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuReservation"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"cpuLimit"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"externalPort"} type={"number | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"applicationStatus"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

<Property name={"createdAt"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"projectId"} type={"string"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mariadb.update" \
  -d '{
  "mariadbId": "string",
  "name": "string",
  "appName": "string",
  "description": "string",
  "databaseName": "string",
  "databaseUser": "string",
  "databasePassword": "string",
  "databaseRootPassword": "string",
  "dockerImage": "mariadb:6",
  "command": "string",
  "env": "string",
  "memoryReservation": 0,
  "memoryLimit": 0,
  "cpuReservation": 0,
  "cpuLimit": 0,
  "externalPort": 0,
  "applicationStatus": "idle",
  "createdAt": "string",
  "projectId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mariadb.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.create"}>

## compose-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"projectId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"composeType"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"docker-compose" | "stack"`</span>

</Property>

<Property name={"appName"} type={"string"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.create" \
  -d '{
  "name": "string",
  "description": "string",
  "projectId": "string",
  "composeType": "docker-compose",
  "appName": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/compose.one"}>

## compose-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"composeId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/compose.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.update"}>

## compose-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"composeId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"name"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"appName"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"description"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"env"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"composeFile"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"refreshToken"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"sourceType"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"git" | "github" | "raw"`</span>

</Property>

<Property name={"composeType"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"docker-compose" | "stack"`</span>

</Property>

<Property name={"repository"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"owner"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"branch"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"autoDeploy"} type={"boolean | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"customGitUrl"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"customGitBranch"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"customGitSSHKey"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"command"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"composePath"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"composeStatus"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"idle" | "running" | "done" | "error"`</span>

</Property>

<Property name={"projectId"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"createdAt"} type={"string"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.update" \
  -d '{
  "composeId": "string",
  "name": "string",
  "appName": "string",
  "description": "string",
  "env": "string",
  "composeFile": "string",
  "refreshToken": "string",
  "sourceType": "git",
  "composeType": "docker-compose",
  "repository": "string",
  "owner": "string",
  "branch": "string",
  "autoDeploy": true,
  "customGitUrl": "string",
  "customGitBranch": "string",
  "customGitSSHKey": "string",
  "command": "string",
  "composePath": "string",
  "composeStatus": "idle",
  "projectId": "string",
  "createdAt": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.delete"}>

## compose-delete

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"composeId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.delete" \
  -d '{
  "composeId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.delete", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.cleanQueues"}>

## compose-cleanQueues

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"composeId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.cleanQueues" \
  -d '{
  "composeId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.cleanQueues", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/compose.allServices"}>

## compose-allServices

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"composeId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/compose.allServices"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.allServices", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.randomizeCompose"}>

## compose-randomizeCompose

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"composeId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"prefix"} type={"string"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.randomizeCompose" \
  -d '{
  "composeId": "string",
  "prefix": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.randomizeCompose", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.deploy"}>

## compose-deploy

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"composeId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.deploy" \
  -d '{
  "composeId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.deploy", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.redeploy"}>

## compose-redeploy

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"composeId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.redeploy" \
  -d '{
  "composeId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.redeploy", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.stop"}>

## compose-stop

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"composeId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.stop" \
  -d '{
  "composeId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.stop", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/compose.getDefaultCommand"}>

## compose-getDefaultCommand

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"composeId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/compose.getDefaultCommand"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.getDefaultCommand", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.generateSSHKey"}>

## compose-generateSSHKey

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"composeId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.generateSSHKey" \
  -d '{
  "composeId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.generateSSHKey", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.refreshToken"}>

## compose-refreshToken

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"composeId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.refreshToken" \
  -d '{
  "composeId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.refreshToken", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.removeSSHKey"}>

## compose-removeSSHKey

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"composeId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.removeSSHKey" \
  -d '{
  "composeId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.removeSSHKey", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/compose.deployTemplate"}>

## compose-deployTemplate

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"projectId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"id"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/compose.deployTemplate" \
  -d '{
  "projectId": "string",
  "id": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.deployTemplate", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/compose.templates"}>

## compose-templates

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/compose.templates"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/compose.templates", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/user.all"}>

## user-all

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/user.all"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/user.all", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/user.byAuthId"}>

## user-byAuthId

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"authId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/user.byAuthId"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/user.byAuthId", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/user.byUserId"}>

## user-byUserId

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"userId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/user.byUserId"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/user.byUserId", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/domain.create"}>

## domain-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"host"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"path"} type={"string | null"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"port"} type={"number | null"} required={true} deprecated={undefined}>

</Property>

<Property name={"https"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"certificateType"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"letsencrypt" | "none"`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/domain.create" \
  -d '{
  "host": "string",
  "path": "string",
  "port": 0,
  "https": true,
  "applicationId": "string",
  "certificateType": "letsencrypt"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/domain.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/domain.byApplicationId"}>

## domain-byApplicationId

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"applicationId"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/domain.byApplicationId"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/domain.byApplicationId", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/domain.update"}>

## domain-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"domainId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"host"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"path"} type={"string | null"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"port"} type={"number | null"} required={true} deprecated={undefined}>

</Property>

<Property name={"https"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

<Property name={"certificateType"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"letsencrypt" | "none"`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/domain.update" \
  -d '{
  "domainId": "string",
  "host": "string",
  "path": "string",
  "port": 0,
  "https": true,
  "certificateType": "letsencrypt"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/domain.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/domain.one"}>

## domain-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"domainId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/domain.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/domain.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/domain.delete"}>

## domain-delete

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"domainId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/domain.delete" \
  -d '{
  "domainId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/domain.delete", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/destination.create"}>

## destination-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"accessKey"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"bucket"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"region"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"endpoint"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"secretAccessKey"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/destination.create" \
  -d '{
  "name": "string",
  "accessKey": "string",
  "bucket": "string",
  "region": "string",
  "endpoint": "string",
  "secretAccessKey": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/destination.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/destination.testConnection"}>

## destination-testConnection

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"accessKey"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"bucket"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"region"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"endpoint"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"secretAccessKey"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/destination.testConnection" \
  -d '{
  "name": "string",
  "accessKey": "string",
  "bucket": "string",
  "region": "string",
  "endpoint": "string",
  "secretAccessKey": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/destination.testConnection", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/destination.one"}>

## destination-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"destinationId"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/destination.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/destination.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/destination.all"}>

## destination-all

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/destination.all"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/destination.all", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/destination.remove"}>

## destination-remove

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"destinationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/destination.remove" \
  -d '{
  "destinationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/destination.remove", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/destination.update"}>

## destination-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"accessKey"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"bucket"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"region"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"endpoint"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"secretAccessKey"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"destinationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/destination.update" \
  -d '{
  "name": "string",
  "accessKey": "string",
  "bucket": "string",
  "region": "string",
  "endpoint": "string",
  "secretAccessKey": "string",
  "destinationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/destination.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/backup.create"}>

## backup-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"schedule"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"enabled"} type={"boolean | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"prefix"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"destinationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"database"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"mariadbId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"mysqlId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"postgresId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"mongoId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"databaseType"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"postgres" | "mariadb" | "mysql" | "mongo"`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/backup.create" \
  -d '{
  "schedule": "string",
  "enabled": true,
  "prefix": "string",
  "destinationId": "string",
  "database": "string",
  "mariadbId": "string",
  "mysqlId": "string",
  "postgresId": "string",
  "mongoId": "string",
  "databaseType": "postgres"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/backup.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/backup.one"}>

## backup-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"backupId"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/backup.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/backup.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/backup.update"}>

## backup-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"schedule"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"enabled"} type={"boolean | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"prefix"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"backupId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"destinationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"database"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/backup.update" \
  -d '{
  "schedule": "string",
  "enabled": true,
  "prefix": "string",
  "backupId": "string",
  "destinationId": "string",
  "database": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/backup.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/backup.remove"}>

## backup-remove

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"backupId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/backup.remove" \
  -d '{
  "backupId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/backup.remove", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/backup.manualBackupPostgres"}>

## backup-manualBackupPostgres

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"backupId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/backup.manualBackupPostgres" \
  -d '{
  "backupId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/backup.manualBackupPostgres", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/backup.manualBackupMySql"}>

## backup-manualBackupMySql

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"backupId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/backup.manualBackupMySql" \
  -d '{
  "backupId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/backup.manualBackupMySql", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/backup.manualBackupMariadb"}>

## backup-manualBackupMariadb

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"backupId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/backup.manualBackupMariadb" \
  -d '{
  "backupId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/backup.manualBackupMariadb", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/backup.manualBackupMongo"}>

## backup-manualBackupMongo

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"backupId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/backup.manualBackupMongo" \
  -d '{
  "backupId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/backup.manualBackupMongo", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/deployment.all"}>

## deployment-all

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"applicationId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/deployment.all"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/deployment.all", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/deployment.allByCompose"}>

## deployment-allByCompose

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"composeId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/deployment.allByCompose"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/deployment.allByCompose", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mounts.create"}>

## mounts-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"type"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"bind" | "volume" | "file"`</span>

</Property>

<Property name={"hostPath"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"volumeName"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"content"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"mountPath"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"serviceType"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"application"`</span>

<span>Value in:  `"application" | "postgres" | "mysql" | "mariadb" | "mongo" | "redis" | "compose"`</span>

</Property>

<Property name={"serviceId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mounts.create" \
  -d '{
  "type": "bind",
  "hostPath": "string",
  "volumeName": "string",
  "content": "string",
  "mountPath": "string",
  "serviceType": "application",
  "serviceId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mounts.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mounts.remove"}>

## mounts-remove

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mountId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mounts.remove" \
  -d '{
  "mountId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mounts.remove", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/mounts.one"}>

## mounts-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"mountId"} type={"string"} required={true} deprecated={false}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/mounts.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mounts.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/mounts.update"}>

## mounts-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"mountId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"type"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"bind" | "volume" | "file"`</span>

</Property>

<Property name={"hostPath"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"volumeName"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"content"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"serviceType"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"application"`</span>

<span>Value in:  `"application" | "postgres" | "mysql" | "mariadb" | "mongo" | "redis" | "compose"`</span>

</Property>

<Property name={"mountPath"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"applicationId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"postgresId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"mariadbId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"mongoId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"mysqlId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"redisId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"composeId"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/mounts.update" \
  -d '{
  "mountId": "string",
  "type": "bind",
  "hostPath": "string",
  "volumeName": "string",
  "content": "string",
  "serviceType": "application",
  "mountPath": "string",
  "applicationId": "string",
  "postgresId": "string",
  "mariadbId": "string",
  "mongoId": "string",
  "mysqlId": "string",
  "redisId": "string",
  "composeId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/mounts.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/certificates.create"}>

## certificates-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"certificateId"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"name"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"certificateData"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"privateKey"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"certificatePath"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"autoRenew"} type={"boolean | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/certificates.create" \
  -d '{
  "certificateId": "string",
  "name": "string",
  "certificateData": "string",
  "privateKey": "string",
  "certificatePath": "string",
  "autoRenew": true
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/certificates.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/certificates.one"}>

## certificates-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"certificateId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/certificates.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/certificates.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/certificates.remove"}>

## certificates-remove

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"certificateId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/certificates.remove" \
  -d '{
  "certificateId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/certificates.remove", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/certificates.all"}>

## certificates-all

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/certificates.all"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/certificates.all", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.reloadServer"}>

## settings-reloadServer

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.reloadServer"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.reloadServer", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.reloadTraefik"}>

## settings-reloadTraefik

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.reloadTraefik"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.reloadTraefik", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.cleanUnusedImages"}>

## settings-cleanUnusedImages

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.cleanUnusedImages"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.cleanUnusedImages", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.cleanUnusedVolumes"}>

## settings-cleanUnusedVolumes

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.cleanUnusedVolumes"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.cleanUnusedVolumes", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.cleanStoppedContainers"}>

## settings-cleanStoppedContainers

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.cleanStoppedContainers"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.cleanStoppedContainers", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.cleanDockerBuilder"}>

## settings-cleanDockerBuilder

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.cleanDockerBuilder"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.cleanDockerBuilder", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.cleanDockerPrune"}>

## settings-cleanDockerPrune

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.cleanDockerPrune"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.cleanDockerPrune", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.cleanAll"}>

## settings-cleanAll

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.cleanAll"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.cleanAll", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.cleanMonitoring"}>

## settings-cleanMonitoring

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.cleanMonitoring"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.cleanMonitoring", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.saveSSHPrivateKey"}>

## settings-saveSSHPrivateKey

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"sshPrivateKey"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.saveSSHPrivateKey" \
  -d '{
  "sshPrivateKey": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.saveSSHPrivateKey", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.assignDomainServer"}>

## settings-assignDomainServer

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"letsEncryptEmail"} type={"string | null"} required={true} deprecated={undefined}>

</Property>

<Property name={"host"} type={"string | null"} required={true} deprecated={undefined}>

</Property>

<Property name={"certificateType"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"none"`</span>

<span>Value in:  `"letsencrypt" | "none"`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.assignDomainServer" \
  -d '{
  "letsEncryptEmail": "string",
  "host": "string",
  "certificateType": "letsencrypt"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.assignDomainServer", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.cleanSSHPrivateKey"}>

## settings-cleanSSHPrivateKey

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.cleanSSHPrivateKey"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.cleanSSHPrivateKey", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.updateDockerCleanup"}>

## settings-updateDockerCleanup

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"enableDockerCleanup"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.updateDockerCleanup" \
  -d '{
  "enableDockerCleanup": true
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.updateDockerCleanup", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/settings.readTraefikConfig"}>

## settings-readTraefikConfig

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/settings.readTraefikConfig"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.readTraefikConfig", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.updateTraefikConfig"}>

## settings-updateTraefikConfig

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"traefikConfig"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.updateTraefikConfig" \
  -d '{
  "traefikConfig": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.updateTraefikConfig", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/settings.readWebServerTraefikConfig"}>

## settings-readWebServerTraefikConfig

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/settings.readWebServerTraefikConfig"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.readWebServerTraefikConfig", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.updateWebServerTraefikConfig"}>

## settings-updateWebServerTraefikConfig

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"traefikConfig"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.updateWebServerTraefikConfig" \
  -d '{
  "traefikConfig": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.updateWebServerTraefikConfig", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/settings.readMiddlewareTraefikConfig"}>

## settings-readMiddlewareTraefikConfig

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/settings.readMiddlewareTraefikConfig"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.readMiddlewareTraefikConfig", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.updateMiddlewareTraefikConfig"}>

## settings-updateMiddlewareTraefikConfig

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"traefikConfig"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.updateMiddlewareTraefikConfig" \
  -d '{
  "traefikConfig": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.updateMiddlewareTraefikConfig", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.checkAndUpdateImage"}>

## settings-checkAndUpdateImage

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.checkAndUpdateImage"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.checkAndUpdateImage", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.updateServer"}>

## settings-updateServer

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.updateServer"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.updateServer", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/settings.getDokployVersion"}>

## settings-getDokployVersion

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/settings.getDokployVersion"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.getDokployVersion", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/settings.readDirectories"}>

## settings-readDirectories

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/settings.readDirectories"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.readDirectories", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/settings.updateTraefikFile"}>

## settings-updateTraefikFile

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"path"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"traefikConfig"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/settings.updateTraefikFile" \
  -d '{
  "path": "string",
  "traefikConfig": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.updateTraefikFile", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/settings.readTraefikFile"}>

## settings-readTraefikFile

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"path"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/settings.readTraefikFile"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.readTraefikFile", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/settings.getOpenApiDocument"}>

## settings-getOpenApiDocument

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/settings.getOpenApiDocument"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/settings.getOpenApiDocument", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/security.create"}>

## security-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"username"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"password"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/security.create" \
  -d '{
  "applicationId": "string",
  "username": "string",
  "password": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/security.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/security.one"}>

## security-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"securityId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/security.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/security.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/security.delete"}>

## security-delete

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"securityId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/security.delete" \
  -d '{
  "securityId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/security.delete", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/security.update"}>

## security-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"securityId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"username"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"password"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/security.update" \
  -d '{
  "securityId": "string",
  "username": "string",
  "password": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/security.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redirects.create"}>

## redirects-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"regex"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"replacement"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"permanent"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redirects.create" \
  -d '{
  "regex": "string",
  "replacement": "string",
  "permanent": true,
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redirects.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/redirects.one"}>

## redirects-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"redirectId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/redirects.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redirects.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redirects.delete"}>

## redirects-delete

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"redirectId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redirects.delete" \
  -d '{
  "redirectId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redirects.delete", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/redirects.update"}>

## redirects-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"redirectId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"regex"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"replacement"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"permanent"} type={"boolean"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/redirects.update" \
  -d '{
  "redirectId": "string",
  "regex": "string",
  "replacement": "string",
  "permanent": true
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/redirects.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/port.create"}>

## port-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"publishedPort"} type={"number"} required={true} deprecated={undefined}>

</Property>

<Property name={"targetPort"} type={"number"} required={true} deprecated={undefined}>

</Property>

<Property name={"protocol"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"tcp"`</span>

<span>Value in:  `"tcp" | "udp"`</span>

</Property>

<Property name={"applicationId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/port.create" \
  -d '{
  "publishedPort": 0,
  "targetPort": 0,
  "protocol": "tcp",
  "applicationId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/port.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/port.one"}>

## port-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"portId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/port.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/port.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/port.delete"}>

## port-delete

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"portId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/port.delete" \
  -d '{
  "portId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/port.delete", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/port.update"}>

## port-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"portId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"publishedPort"} type={"number"} required={true} deprecated={undefined}>

</Property>

<Property name={"targetPort"} type={"number"} required={true} deprecated={undefined}>

</Property>

<Property name={"protocol"} type={"string"} required={false} deprecated={undefined}>

<span>Default:  `"tcp"`</span>

<span>Value in:  `"tcp" | "udp"`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/port.update" \
  -d '{
  "portId": "string",
  "publishedPort": 0,
  "targetPort": 0,
  "protocol": "tcp"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/port.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/registry.create"}>

## registry-create

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"registryName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"username"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"password"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"registryUrl"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"registryType"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"selfHosted" | "cloud"`</span>

</Property>

<Property name={"imagePrefix"} type={"string | null"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/registry.create" \
  -d '{
  "registryName": "string",
  "username": "string",
  "password": "string",
  "registryUrl": "string",
  "registryType": "selfHosted",
  "imagePrefix": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/registry.create", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/registry.remove"}>

## registry-remove

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"registryId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/registry.remove" \
  -d '{
  "registryId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/registry.remove", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/registry.update"}>

## registry-update

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"registryId"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"registryName"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"imagePrefix"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

<Property name={"username"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"password"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"registryUrl"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"createdAt"} type={"string"} required={false} deprecated={undefined}>

</Property>

<Property name={"registryType"} type={"string"} required={false} deprecated={undefined}>

<span>Value in:  `"selfHosted" | "cloud"`</span>

</Property>

<Property name={"adminId"} type={"string"} required={false} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/registry.update" \
  -d '{
  "registryId": "string",
  "registryName": "string",
  "imagePrefix": "string",
  "username": "string",
  "password": "string",
  "registryUrl": "string",
  "createdAt": "string",
  "registryType": "selfHosted",
  "adminId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/registry.update", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/registry.all"}>

## registry-all

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/registry.all"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/registry.all", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/registry.one"}>

## registry-one

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Query Parameters

<Property name={"registryId"} type={"string"} required={true} deprecated={false}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/registry.one"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/registry.one", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/registry.testRegistry"}>

## registry-testRegistry

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"registryName"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"username"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"password"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"registryUrl"} type={"string"} required={true} deprecated={undefined}>

</Property>

<Property name={"registryType"} type={"string"} required={true} deprecated={undefined}>

<span>Value in:  `"selfHosted" | "cloud"`</span>

</Property>

<Property name={"imagePrefix"} type={"string | null"} required={false} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/registry.testRegistry" \
  -d '{
  "registryName": "string",
  "username": "string",
  "password": "string",
  "registryUrl": "string",
  "registryType": "selfHosted",
  "imagePrefix": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/registry.testRegistry", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/registry.enableSelfHostedRegistry"}>

## registry-enableSelfHostedRegistry

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"registryUrl"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"username"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

<Property name={"password"} type={"string"} required={true} deprecated={undefined}>

<span>Minimum length:  `1`</span>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/registry.enableSelfHostedRegistry" \
  -d '{
  "registryUrl": "string",
  "username": "string",
  "password": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/registry.enableSelfHostedRegistry", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/cluster.getNodes"}>

## cluster-getNodes

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/cluster.getNodes"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/cluster.getNodes", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"POST"} route={"/cluster.removeWorker"}>

## cluster-removeWorker

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

### Request Body

<Property name={"nodeId"} type={"string"} required={true} deprecated={undefined}>

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X POST "http://localhost:3000/cluster.removeWorker" \
  -d '{
  "nodeId": "string"
}'
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/cluster.removeWorker", {
  method: "POST"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/cluster.addWorker"}>

## cluster-addWorker

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/cluster.addWorker"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/cluster.addWorker", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

<API>

<APIInfo method={"GET"} route={"/cluster.addManager"}>

## cluster-addManager

### Authorization

<Property name={"Authorization"} type={"Bearer <token>"} required={true}>

In: `header`

</Property>

| Status code | Description |
| ----------- | ----------- |
| `200` | Successful response |
| `default` | Error response |

</APIInfo>

<APIExample>

<Requests items={["cURL","JavaScript"]}>

<Request value={"cURL"}>

```bash
curl -X GET "http://localhost:3000/cluster.addManager"
```

</Request>

<Request value={"JavaScript"}>

```js
fetch("http://localhost:3000/cluster.addManager", {
  method: "GET"
});
```

</Request>

</Requests>

<Responses items={["default"]}>

<Response value={"default"}>

<ResponseTypes>

<ExampleResponse>

```json
{
  "message": "string",
  "code": "string",
  "issues": [
    {
      "message": "string"
    }
  ]
}
```

</ExampleResponse>

<TypeScriptResponse>

```ts
export interface Response {
  message: string;
  code: string;
  issues?: {
    message: string;
  }[];
}
```

</TypeScriptResponse>

</ResponseTypes>

</Response>

</Responses>

</APIExample>

</API>

</Root>