timeweb_rs/apis/
servers_api.rs

1/*
2 * Документация публичного API
3 *
4 * # Введение API Timeweb Cloud позволяет вам управлять ресурсами в облаке программным способом с использованием обычных HTTP-запросов.  Множество функций, которые доступны в панели управления Timeweb Cloud, также доступны через API, что позволяет вам автоматизировать ваши собственные сценарии.  В этой документации сперва будет описан общий дизайн и принципы работы API, а после этого конкретные конечные точки. Также будут приведены примеры запросов к ним.   ## Запросы Запросы должны выполняться по протоколу `HTTPS`, чтобы гарантировать шифрование транзакций. Поддерживаются следующие методы запроса: |Метод|Применение| |--- |--- | |GET|Извлекает данные о коллекциях и отдельных ресурсах.| |POST|Для коллекций создает новый ресурс этого типа. Также используется для выполнения действий с конкретным ресурсом.| |PUT|Обновляет существующий ресурс.| |PATCH|Некоторые ресурсы поддерживают частичное обновление, то есть обновление только части атрибутов ресурса, в этом случае вместо метода PUT будет использован PATCH.| |DELETE|Удаляет ресурс.|  Методы `POST`, `PUT` и `PATCH` могут включать объект в тело запроса с типом содержимого `application/json`.  ### Параметры в запросах Некоторые коллекции поддерживают пагинацию, поиск или сортировку в запросах. В параметрах запроса требуется передать: - `limit` — обозначает количество записей, которое необходимо вернуть  - `offset` — указывает на смещение, относительно начала списка  - `search` — позволяет указать набор символов для поиска  - `sort` — можно задать правило сортировки коллекции  ## Ответы Запросы вернут один из следующих кодов состояния ответа HTTP:  |Статус|Описание| |--- |--- | |200 OK|Действие с ресурсом было выполнено успешно.| |201 Created|Ресурс был успешно создан. При этом ресурс может быть как уже готовым к использованию, так и находиться в процессе запуска.| |204 No Content|Действие с ресурсом было выполнено успешно, и ответ не содержит дополнительной информации в теле.| |400 Bad Request|Был отправлен неверный запрос, например, в нем отсутствуют обязательные параметры и т. д. Тело ответа будет содержать дополнительную информацию об ошибке.| |401 Unauthorized|Ошибка аутентификации.| |403 Forbidden|Аутентификация прошла успешно, но недостаточно прав для выполнения действия.| |404 Not Found|Запрашиваемый ресурс не найден.| |409 Conflict|Запрос конфликтует с текущим состоянием.| |423 Locked|Ресурс из запроса заблокирован от применения к нему указанного метода.| |429 Too Many Requests|Был достигнут лимит по количеству запросов в единицу времени.| |500 Internal Server Error|При выполнении запроса произошла какая-то внутренняя ошибка. Чтобы решить эту проблему, лучше всего создать тикет в панели управления.|  ### Структура успешного ответа Все конечные точки будут возвращать данные в формате `JSON`. Ответы на `GET`-запросы будут иметь на верхнем уровне следующую структуру атрибутов:  |Название поля|Тип|Описание| |--- |--- |--- | |[entity_name]|object, object[], string[], number[], boolean|Динамическое поле, которое будет меняться в зависимости от запрашиваемого ресурса и будет содержать все атрибуты, необходимые для описания этого ресурса. Например, при запросе списка баз данных будет возвращаться поле `dbs`, а при запросе конкретного облачного сервера `server`. Для некоторых конечных точек в ответе может возвращаться сразу несколько ресурсов.| |meta|object|Опционально. Объект, который содержит вспомогательную информацию о ресурсе. Чаще всего будет встречаться при запросе коллекций и содержать поле `total`, которое будет указывать на количество элементов в коллекции.| |response_id|string|Опционально. В большинстве случаев в ответе будет содержаться ID ответа в формате UUIDv4, который однозначно указывает на ваш запрос внутри нашей системы. Если вам потребуется задать вопрос нашей поддержке, приложите к вопросу этот ID— так мы сможем найти ответ на него намного быстрее. Также вы можете использовать этот ID, чтобы убедиться, что это новый ответ на запрос и результат не был получен из кэша.|  Пример запроса на получение списка SSH-ключей: ```     HTTP/2.0 200 OK     {       \"ssh_keys\":[           {             \"body\":\"ssh-rsa AAAAB3NzaC1sdfghjkOAsBwWhs= example@device.local\",             \"created_at\":\"2021-09-15T19:52:27Z\",             \"expired_at\":null,             \"id\":5297,             \"is_default\":false,             \"name\":\"example@device.local\",             \"used_at\":null,             \"used_by\":[]           }       ],       \"meta\":{           \"total\":1       },       \"response_id\":\"94608d15-8672-4eed-8ab6-28bd6fa3cdf7\"     } ```  ### Структура ответа с ошибкой |Название поля|Тип|Описание| |--- |--- |--- | |status_code|number|Короткий числовой идентификатор ошибки.| |error_code|string|Короткий текстовый идентификатор ошибки, который уточняет числовой идентификатор и удобен для программной обработки. Самый простой пример — это код `not_found` для ошибки 404.| |message|string, string[]|Опционально. В большинстве случаев в ответе будет содержаться человекочитаемое подробное описание ошибки или ошибок, которые помогут понять, что нужно исправить.| |response_id|string|Опционально. В большинстве случае в ответе будет содержаться ID ответа в формате UUIDv4, который однозначно указывает на ваш запрос внутри нашей системы. Если вам потребуется задать вопрос нашей поддержке, приложите к вопросу этот ID — так мы сможем найти ответ на него намного быстрее.|  Пример: ```     HTTP/2.0 403 Forbidden     {       \"status_code\": 403,       \"error_code\":  \"forbidden\",       \"message\":     \"You do not have access for the attempted action\",       \"response_id\": \"94608d15-8672-4eed-8ab6-28bd6fa3cdf7\"     } ```  ## Статусы ресурсов Важно учесть, что при создании большинства ресурсов внутри платформы вам будет сразу возвращен ответ от сервера со статусом `200 OK` или `201 Created` и ID созданного ресурса в теле ответа, но при этом этот ресурс может быть ещё в *состоянии запуска*.  Для того чтобы понять, в каком состоянии сейчас находится ваш ресурс, мы добавили поле `status` в ответ на получение информации о ресурсе.  Список статусов будет отличаться в зависимости от типа ресурса. Увидеть поддерживаемый список статусов вы сможете в описании каждого конкретного ресурса.     ## Ограничение скорости запросов (Rate Limiting) Чтобы обеспечить стабильность для всех пользователей, Timeweb Cloud защищает API от всплесков входящего трафика, анализируя количество запросов c каждого аккаунта к каждой конечной точке.  Если ваше приложение отправляет более 20 запросов в секунду на одну конечную точку, то для этого запроса API может вернуть код состояния HTTP `429 Too Many Requests`.   ## Аутентификация Доступ к API осуществляется с помощью JWT-токена. Токенами можно управлять внутри панели управления Timeweb Cloud в разделе *API и Terraform*.  Токен необходимо передавать в заголовке каждого запроса в формате: ```   Authorization: Bearer $TIMEWEB_CLOUD_TOKEN ```  ## Формат примеров API Примеры в этой документации описаны с помощью `curl`, HTTP-клиента командной строки. На компьютерах `Linux` и `macOS` обычно по умолчанию установлен `curl`, и он доступен для загрузки на всех популярных платформах, включая `Windows`.  Каждый пример разделен на несколько строк символом `\\`, который совместим с `bash`. Типичный пример выглядит так: ```   curl -X PATCH      -H \"Content-Type: application/json\"      -H \"Authorization: Bearer $TIMEWEB_CLOUD_TOKEN\"      -d '{\"name\":\"Cute Corvus\",\"comment\":\"Development Server\"}'      \"https://api.timeweb.cloud/api/v1/dedicated/1051\" ``` - Параметр `-X` задает метод запроса. Для согласованности метод будет указан во всех примерах, даже если он явно не требуется для методов `GET`. - Строки `-H` задают требуемые HTTP-заголовки. - Примеры, для которых требуется объект JSON в теле запроса, передают требуемые данные через параметр `-d`.  Чтобы использовать приведенные примеры, не подставляя каждый раз в них свой токен, вы можете добавить токен один раз в переменные окружения в вашей консоли. Например, на `Linux` это можно сделать с помощью команды:  ``` TIMEWEB_CLOUD_TOKEN=\"token\" ```  После этого токен будет автоматически подставляться в ваши запросы.  Обратите внимание, что все значения в этой документации являются примерами. Не полагайтесь на IDы операционных систем, тарифов и т.д., используемые в примерах. Используйте соответствующую конечную точку для получения значений перед созданием ресурсов.   ## Версионирование API построено согласно принципам [семантического версионирования](https://semver.org/lang/ru). Это значит, что мы гарантируем обратную совместимость всех изменений в пределах одной мажорной версии.  Мажорная версия каждой конечной точки обозначается в пути запроса, например, запрос `/api/v1/servers` указывает, что этот метод имеет версию 1.
5 *
6 * The version of the OpenAPI document: 1.0.0
7 * Contact: info@timeweb.cloud
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12use serde::{Deserialize, Serialize, de::Error as _};
13
14use super::{ContentType, Error, configuration};
15use crate::{apis::ResponseContent, models};
16
17/// struct for typed errors of method [`add_server_ip`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum AddServerIpError {
21    Status400(models::GetFinances400Response),
22    Status401(models::GetFinances401Response),
23    Status403(models::GetAccountStatus403Response),
24    Status404(models::GetImage404Response),
25    Status409(models::CreateDatabaseBackup409Response),
26    Status429(models::GetFinances429Response),
27    Status500(models::GetFinances500Response),
28    UnknownValue(serde_json::Value)
29}
30
31/// struct for typed errors of method [`clone_server`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum CloneServerError {
35    Status400(models::GetFinances400Response),
36    Status401(models::GetFinances401Response),
37    Status403(models::GetAccountStatus403Response),
38    Status409(models::CreateDatabaseBackup409Response),
39    Status429(models::GetFinances429Response),
40    Status500(models::GetFinances500Response),
41    UnknownValue(serde_json::Value)
42}
43
44/// struct for typed errors of method [`create_server`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum CreateServerError {
48    Status400(models::GetFinances400Response),
49    Status401(models::GetFinances401Response),
50    Status403(models::GetAccountStatus403Response),
51    Status409(models::CreateDatabaseBackup409Response),
52    Status429(models::GetFinances429Response),
53    Status500(models::GetFinances500Response),
54    UnknownValue(serde_json::Value)
55}
56
57/// struct for typed errors of method [`create_server_disk`]
58#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum CreateServerDiskError {
61    Status400(models::GetFinances400Response),
62    Status401(models::GetFinances401Response),
63    Status403(models::GetAccountStatus403Response),
64    Status404(models::GetImage404Response),
65    Status409(models::CreateDatabaseBackup409Response),
66    Status429(models::GetFinances429Response),
67    Status500(models::GetFinances500Response),
68    UnknownValue(serde_json::Value)
69}
70
71/// struct for typed errors of method [`create_server_disk_backup`]
72#[derive(Debug, Clone, Serialize, Deserialize)]
73#[serde(untagged)]
74pub enum CreateServerDiskBackupError {
75    Status400(models::GetFinances400Response),
76    Status401(models::GetFinances401Response),
77    Status403(models::GetAccountStatus403Response),
78    Status404(models::GetImage404Response),
79    Status429(models::GetFinances429Response),
80    Status500(models::GetFinances500Response),
81    UnknownValue(serde_json::Value)
82}
83
84/// struct for typed errors of method [`delete_server`]
85#[derive(Debug, Clone, Serialize, Deserialize)]
86#[serde(untagged)]
87pub enum DeleteServerError {
88    Status400(models::GetFinances400Response),
89    Status401(models::GetFinances401Response),
90    Status403(models::GetAccountStatus403Response),
91    Status404(models::GetImage404Response),
92    Status409(models::CreateDatabaseBackup409Response),
93    Status429(models::GetFinances429Response),
94    Status500(models::GetFinances500Response),
95    UnknownValue(serde_json::Value)
96}
97
98/// struct for typed errors of method [`delete_server_disk`]
99#[derive(Debug, Clone, Serialize, Deserialize)]
100#[serde(untagged)]
101pub enum DeleteServerDiskError {
102    Status400(models::GetFinances400Response),
103    Status401(models::GetFinances401Response),
104    Status403(models::GetAccountStatus403Response),
105    Status404(models::GetImage404Response),
106    Status409(models::CreateDatabaseBackup409Response),
107    Status429(models::GetFinances429Response),
108    Status500(models::GetFinances500Response),
109    UnknownValue(serde_json::Value)
110}
111
112/// struct for typed errors of method [`delete_server_disk_backup`]
113#[derive(Debug, Clone, Serialize, Deserialize)]
114#[serde(untagged)]
115pub enum DeleteServerDiskBackupError {
116    Status400(models::GetFinances400Response),
117    Status401(models::GetFinances401Response),
118    Status403(models::GetAccountStatus403Response),
119    Status404(models::GetImage404Response),
120    Status409(models::CreateDatabaseBackup409Response),
121    Status429(models::GetFinances429Response),
122    Status500(models::GetFinances500Response),
123    UnknownValue(serde_json::Value)
124}
125
126/// struct for typed errors of method [`delete_server_ip`]
127#[derive(Debug, Clone, Serialize, Deserialize)]
128#[serde(untagged)]
129pub enum DeleteServerIpError {
130    Status400(models::GetFinances400Response),
131    Status401(models::GetFinances401Response),
132    Status403(models::GetAccountStatus403Response),
133    Status404(models::GetImage404Response),
134    Status409(models::CreateDatabaseBackup409Response),
135    Status429(models::GetFinances429Response),
136    Status500(models::GetFinances500Response),
137    UnknownValue(serde_json::Value)
138}
139
140/// struct for typed errors of method [`get_configurators`]
141#[derive(Debug, Clone, Serialize, Deserialize)]
142#[serde(untagged)]
143pub enum GetConfiguratorsError {
144    Status400(models::GetFinances400Response),
145    Status401(models::GetFinances401Response),
146    Status403(models::GetAccountStatus403Response),
147    Status429(models::GetFinances429Response),
148    Status500(models::GetFinances500Response),
149    UnknownValue(serde_json::Value)
150}
151
152/// struct for typed errors of method [`get_os_list`]
153#[derive(Debug, Clone, Serialize, Deserialize)]
154#[serde(untagged)]
155pub enum GetOsListError {
156    Status400(models::GetFinances400Response),
157    Status401(models::GetFinances401Response),
158    Status403(models::GetAccountStatus403Response),
159    Status404(models::GetImage404Response),
160    Status429(models::GetFinances429Response),
161    Status500(models::GetFinances500Response),
162    UnknownValue(serde_json::Value)
163}
164
165/// struct for typed errors of method [`get_server`]
166#[derive(Debug, Clone, Serialize, Deserialize)]
167#[serde(untagged)]
168pub enum GetServerError {
169    Status400(models::GetFinances400Response),
170    Status401(models::GetFinances401Response),
171    Status403(models::GetAccountStatus403Response),
172    Status404(models::GetImage404Response),
173    Status409(models::CreateDatabaseBackup409Response),
174    Status429(models::GetFinances429Response),
175    Status500(models::GetFinances500Response),
176    UnknownValue(serde_json::Value)
177}
178
179/// struct for typed errors of method [`get_server_disk`]
180#[derive(Debug, Clone, Serialize, Deserialize)]
181#[serde(untagged)]
182pub enum GetServerDiskError {
183    Status400(models::GetFinances400Response),
184    Status401(models::GetFinances401Response),
185    Status403(models::GetAccountStatus403Response),
186    Status404(models::GetImage404Response),
187    Status409(models::CreateDatabaseBackup409Response),
188    Status429(models::GetFinances429Response),
189    Status500(models::GetFinances500Response),
190    UnknownValue(serde_json::Value)
191}
192
193/// struct for typed errors of method [`get_server_disk_auto_backup_settings`]
194#[derive(Debug, Clone, Serialize, Deserialize)]
195#[serde(untagged)]
196pub enum GetServerDiskAutoBackupSettingsError {
197    Status400(models::GetFinances400Response),
198    Status401(models::GetFinances401Response),
199    Status403(models::GetAccountStatus403Response),
200    Status404(models::GetImage404Response),
201    Status429(models::GetFinances429Response),
202    Status500(models::GetFinances500Response),
203    UnknownValue(serde_json::Value)
204}
205
206/// struct for typed errors of method [`get_server_disk_backup`]
207#[derive(Debug, Clone, Serialize, Deserialize)]
208#[serde(untagged)]
209pub enum GetServerDiskBackupError {
210    Status400(models::GetFinances400Response),
211    Status401(models::GetFinances401Response),
212    Status403(models::GetAccountStatus403Response),
213    Status404(models::GetImage404Response),
214    Status429(models::GetFinances429Response),
215    Status500(models::GetFinances500Response),
216    UnknownValue(serde_json::Value)
217}
218
219/// struct for typed errors of method [`get_server_disk_backups`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum GetServerDiskBackupsError {
223    Status400(models::GetFinances400Response),
224    Status401(models::GetFinances401Response),
225    Status403(models::GetAccountStatus403Response),
226    Status404(models::GetImage404Response),
227    Status429(models::GetFinances429Response),
228    Status500(models::GetFinances500Response),
229    UnknownValue(serde_json::Value)
230}
231
232/// struct for typed errors of method [`get_server_disks`]
233#[derive(Debug, Clone, Serialize, Deserialize)]
234#[serde(untagged)]
235pub enum GetServerDisksError {
236    Status400(models::GetFinances400Response),
237    Status401(models::GetFinances401Response),
238    Status403(models::GetAccountStatus403Response),
239    Status404(models::GetImage404Response),
240    Status409(models::CreateDatabaseBackup409Response),
241    Status429(models::GetFinances429Response),
242    Status500(models::GetFinances500Response),
243    UnknownValue(serde_json::Value)
244}
245
246/// struct for typed errors of method [`get_server_ips`]
247#[derive(Debug, Clone, Serialize, Deserialize)]
248#[serde(untagged)]
249pub enum GetServerIpsError {
250    Status400(models::GetFinances400Response),
251    Status401(models::GetFinances401Response),
252    Status403(models::GetAccountStatus403Response),
253    Status404(models::GetImage404Response),
254    Status409(models::CreateDatabaseBackup409Response),
255    Status429(models::GetFinances429Response),
256    Status500(models::GetFinances500Response),
257    UnknownValue(serde_json::Value)
258}
259
260/// struct for typed errors of method [`get_server_logs`]
261#[derive(Debug, Clone, Serialize, Deserialize)]
262#[serde(untagged)]
263pub enum GetServerLogsError {
264    Status400(models::GetFinances400Response),
265    Status401(models::GetFinances401Response),
266    Status403(models::GetAccountStatus403Response),
267    Status404(models::GetImage404Response),
268    Status409(models::CreateDatabaseBackup409Response),
269    Status429(models::GetFinances429Response),
270    Status500(models::GetFinances500Response),
271    UnknownValue(serde_json::Value)
272}
273
274/// struct for typed errors of method [`get_server_statistics`]
275#[derive(Debug, Clone, Serialize, Deserialize)]
276#[serde(untagged)]
277pub enum GetServerStatisticsError {
278    Status400(models::GetFinances400Response),
279    Status401(models::GetFinances401Response),
280    Status403(models::GetAccountStatus403Response),
281    Status404(models::GetImage404Response),
282    Status409(models::CreateDatabaseBackup409Response),
283    Status429(models::GetFinances429Response),
284    Status500(models::GetFinances500Response),
285    UnknownValue(serde_json::Value)
286}
287
288/// struct for typed errors of method [`get_server_statistics_new`]
289#[derive(Debug, Clone, Serialize, Deserialize)]
290#[serde(untagged)]
291pub enum GetServerStatisticsNewError {
292    Status400(models::GetFinances400Response),
293    Status401(models::GetFinances401Response),
294    Status403(models::GetAccountStatus403Response),
295    Status404(models::GetImage404Response),
296    Status409(models::CreateDatabaseBackup409Response),
297    Status429(models::GetFinances429Response),
298    Status500(models::GetFinances500Response),
299    UnknownValue(serde_json::Value)
300}
301
302/// struct for typed errors of method [`get_servers`]
303#[derive(Debug, Clone, Serialize, Deserialize)]
304#[serde(untagged)]
305pub enum GetServersError {
306    Status400(models::GetFinances400Response),
307    Status401(models::GetFinances401Response),
308    Status403(models::GetAccountStatus403Response),
309    Status404(models::GetImage404Response),
310    Status429(models::GetFinances429Response),
311    Status500(models::GetFinances500Response),
312    UnknownValue(serde_json::Value)
313}
314
315/// struct for typed errors of method [`get_servers_presets`]
316#[derive(Debug, Clone, Serialize, Deserialize)]
317#[serde(untagged)]
318pub enum GetServersPresetsError {
319    Status400(models::GetFinances400Response),
320    Status401(models::GetFinances401Response),
321    Status403(models::GetAccountStatus403Response),
322    Status429(models::GetFinances429Response),
323    Status500(models::GetFinances500Response),
324    UnknownValue(serde_json::Value)
325}
326
327/// struct for typed errors of method [`get_software`]
328#[derive(Debug, Clone, Serialize, Deserialize)]
329#[serde(untagged)]
330pub enum GetSoftwareError {
331    Status400(models::GetFinances400Response),
332    Status401(models::GetFinances401Response),
333    Status403(models::GetAccountStatus403Response),
334    Status404(models::GetImage404Response),
335    Status429(models::GetFinances429Response),
336    Status500(models::GetFinances500Response),
337    UnknownValue(serde_json::Value)
338}
339
340/// struct for typed errors of method [`hard_shutdown_server`]
341#[derive(Debug, Clone, Serialize, Deserialize)]
342#[serde(untagged)]
343pub enum HardShutdownServerError {
344    Status400(models::GetFinances400Response),
345    Status401(models::GetFinances401Response),
346    Status403(models::GetAccountStatus403Response),
347    Status409(models::CreateDatabaseBackup409Response),
348    Status429(models::GetFinances429Response),
349    Status500(models::GetFinances500Response),
350    UnknownValue(serde_json::Value)
351}
352
353/// struct for typed errors of method [`image_unmount_and_server_reload`]
354#[derive(Debug, Clone, Serialize, Deserialize)]
355#[serde(untagged)]
356pub enum ImageUnmountAndServerReloadError {
357    Status400(models::GetFinances400Response),
358    Status401(models::GetFinances401Response),
359    Status404(models::GetImage404Response),
360    Status429(models::GetFinances429Response),
361    Status500(models::GetFinances500Response),
362    UnknownValue(serde_json::Value)
363}
364
365/// struct for typed errors of method [`perform_action_on_backup`]
366#[derive(Debug, Clone, Serialize, Deserialize)]
367#[serde(untagged)]
368pub enum PerformActionOnBackupError {
369    Status400(models::GetFinances400Response),
370    Status401(models::GetFinances401Response),
371    Status403(models::GetAccountStatus403Response),
372    Status404(models::GetImage404Response),
373    Status409(models::CreateDatabaseBackup409Response),
374    Status429(models::GetFinances429Response),
375    Status500(models::GetFinances500Response),
376    UnknownValue(serde_json::Value)
377}
378
379/// struct for typed errors of method [`perform_action_on_server`]
380#[derive(Debug, Clone, Serialize, Deserialize)]
381#[serde(untagged)]
382pub enum PerformActionOnServerError {
383    Status400(models::GetFinances400Response),
384    Status401(models::GetFinances401Response),
385    Status403(models::GetAccountStatus403Response),
386    Status404(models::GetImage404Response),
387    Status409(models::CreateDatabaseBackup409Response),
388    Status429(models::GetFinances429Response),
389    Status500(models::GetFinances500Response),
390    UnknownValue(serde_json::Value)
391}
392
393/// struct for typed errors of method [`reboot_server`]
394#[derive(Debug, Clone, Serialize, Deserialize)]
395#[serde(untagged)]
396pub enum RebootServerError {
397    Status400(models::GetFinances400Response),
398    Status401(models::GetFinances401Response),
399    Status403(models::GetAccountStatus403Response),
400    Status409(models::CreateDatabaseBackup409Response),
401    Status429(models::GetFinances429Response),
402    Status500(models::GetFinances500Response),
403    UnknownValue(serde_json::Value)
404}
405
406/// struct for typed errors of method [`reboot_server_hard`]
407#[derive(Debug, Clone, Serialize, Deserialize)]
408#[serde(untagged)]
409pub enum RebootServerHardError {
410    Status400(models::GetFinances400Response),
411    Status401(models::GetFinances401Response),
412    Status403(models::GetAccountStatus403Response),
413    Status409(models::CreateDatabaseBackup409Response),
414    Status429(models::GetFinances429Response),
415    Status500(models::GetFinances500Response),
416    UnknownValue(serde_json::Value)
417}
418
419/// struct for typed errors of method [`reset_server_password`]
420#[derive(Debug, Clone, Serialize, Deserialize)]
421#[serde(untagged)]
422pub enum ResetServerPasswordError {
423    Status400(models::GetFinances400Response),
424    Status401(models::GetFinances401Response),
425    Status409(models::CreateDatabaseBackup409Response),
426    Status429(models::GetFinances429Response),
427    Status500(models::GetFinances500Response),
428    UnknownValue(serde_json::Value)
429}
430
431/// struct for typed errors of method [`shutdown_server`]
432#[derive(Debug, Clone, Serialize, Deserialize)]
433#[serde(untagged)]
434pub enum ShutdownServerError {
435    Status400(models::GetFinances400Response),
436    Status401(models::GetFinances401Response),
437    Status403(models::GetAccountStatus403Response),
438    Status409(models::CreateDatabaseBackup409Response),
439    Status429(models::GetFinances429Response),
440    Status500(models::GetFinances500Response),
441    UnknownValue(serde_json::Value)
442}
443
444/// struct for typed errors of method [`start_server`]
445#[derive(Debug, Clone, Serialize, Deserialize)]
446#[serde(untagged)]
447pub enum StartServerError {
448    Status400(models::GetFinances400Response),
449    Status401(models::GetFinances401Response),
450    Status409(models::CreateDatabaseBackup409Response),
451    Status429(models::GetFinances429Response),
452    Status500(models::GetFinances500Response),
453    UnknownValue(serde_json::Value)
454}
455
456/// struct for typed errors of method [`update_server`]
457#[derive(Debug, Clone, Serialize, Deserialize)]
458#[serde(untagged)]
459pub enum UpdateServerError {
460    Status400(models::GetFinances400Response),
461    Status401(models::GetFinances401Response),
462    Status403(models::GetAccountStatus403Response),
463    Status404(models::GetImage404Response),
464    Status409(models::CreateDatabaseBackup409Response),
465    Status429(models::GetFinances429Response),
466    Status500(models::GetFinances500Response),
467    UnknownValue(serde_json::Value)
468}
469
470/// struct for typed errors of method [`update_server_disk`]
471#[derive(Debug, Clone, Serialize, Deserialize)]
472#[serde(untagged)]
473pub enum UpdateServerDiskError {
474    Status400(models::GetFinances400Response),
475    Status401(models::GetFinances401Response),
476    Status403(models::GetAccountStatus403Response),
477    Status404(models::GetImage404Response),
478    Status409(models::CreateDatabaseBackup409Response),
479    Status429(models::GetFinances429Response),
480    Status500(models::GetFinances500Response),
481    UnknownValue(serde_json::Value)
482}
483
484/// struct for typed errors of method
485/// [`update_server_disk_auto_backup_settings`]
486#[derive(Debug, Clone, Serialize, Deserialize)]
487#[serde(untagged)]
488pub enum UpdateServerDiskAutoBackupSettingsError {
489    Status400(models::GetFinances400Response),
490    Status401(models::GetFinances401Response),
491    Status403(models::GetAccountStatus403Response),
492    Status404(models::GetImage404Response),
493    Status429(models::GetFinances429Response),
494    Status500(models::GetFinances500Response),
495    UnknownValue(serde_json::Value)
496}
497
498/// struct for typed errors of method [`update_server_disk_backup`]
499#[derive(Debug, Clone, Serialize, Deserialize)]
500#[serde(untagged)]
501pub enum UpdateServerDiskBackupError {
502    Status400(models::GetFinances400Response),
503    Status401(models::GetFinances401Response),
504    Status403(models::GetAccountStatus403Response),
505    Status404(models::GetImage404Response),
506    Status429(models::GetFinances429Response),
507    Status500(models::GetFinances500Response),
508    UnknownValue(serde_json::Value)
509}
510
511/// struct for typed errors of method [`update_server_ip`]
512#[derive(Debug, Clone, Serialize, Deserialize)]
513#[serde(untagged)]
514pub enum UpdateServerIpError {
515    Status400(models::GetFinances400Response),
516    Status401(models::GetFinances401Response),
517    Status403(models::GetAccountStatus403Response),
518    Status404(models::GetImage404Response),
519    Status409(models::CreateDatabaseBackup409Response),
520    Status429(models::GetFinances429Response),
521    Status500(models::GetFinances500Response),
522    UnknownValue(serde_json::Value)
523}
524
525/// struct for typed errors of method [`update_server_nat`]
526#[derive(Debug, Clone, Serialize, Deserialize)]
527#[serde(untagged)]
528pub enum UpdateServerNatError {
529    Status400(models::GetFinances400Response),
530    Status401(models::GetFinances401Response),
531    Status403(models::GetAccountStatus403Response),
532    Status404(models::GetImage404Response),
533    Status409(models::CreateDatabaseBackup409Response),
534    Status429(models::GetFinances429Response),
535    Status500(models::GetFinances500Response),
536    UnknownValue(serde_json::Value)
537}
538
539/// struct for typed errors of method [`update_server_os_boot_mode`]
540#[derive(Debug, Clone, Serialize, Deserialize)]
541#[serde(untagged)]
542pub enum UpdateServerOsBootModeError {
543    Status400(models::GetFinances400Response),
544    Status401(models::GetFinances401Response),
545    Status403(models::GetAccountStatus403Response),
546    Status404(models::GetImage404Response),
547    Status409(models::CreateDatabaseBackup409Response),
548    Status429(models::GetFinances429Response),
549    Status500(models::GetFinances500Response),
550    UnknownValue(serde_json::Value)
551}
552
553/// Чтобы добавить IP-адрес сервера, отправьте POST-запрос на
554/// `/api/v1/servers/{server_id}/ips`. \\  На данный момент IPv6 доступны только
555/// для серверов с локацией `ru-1`.
556pub async fn add_server_ip(
557    configuration: &configuration::Configuration,
558    server_id: i32,
559    add_server_ip_request: models::AddServerIpRequest
560) -> Result<models::AddServerIp201Response, Error<AddServerIpError>> {
561    // add a prefix to parameters to efficiently prevent name collisions
562    let p_path_server_id = server_id;
563    let p_body_add_server_ip_request = add_server_ip_request;
564
565    let uri_str = format!(
566        "{}/api/v1/servers/{server_id}/ips",
567        configuration.base_path,
568        server_id = p_path_server_id
569    );
570    let mut req_builder = configuration
571        .client
572        .request(reqwest::Method::POST, &uri_str);
573
574    if let Some(ref user_agent) = configuration.user_agent {
575        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
576    }
577    if let Some(ref token) = configuration.bearer_access_token {
578        req_builder = req_builder.bearer_auth(token.to_owned());
579    };
580    req_builder = req_builder.json(&p_body_add_server_ip_request);
581
582    let req = req_builder.build()?;
583    let resp = configuration.client.execute(req).await?;
584
585    let status = resp.status();
586    let content_type = resp
587        .headers()
588        .get("content-type")
589        .and_then(|v| v.to_str().ok())
590        .unwrap_or("application/octet-stream");
591    let content_type = super::ContentType::from(content_type);
592
593    if !status.is_client_error() && !status.is_server_error() {
594        let content = resp.text().await?;
595        match content_type {
596            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
597            ContentType::Text => {
598                return Err(Error::from(serde_json::Error::custom(
599                    "Received `text/plain` content type response that cannot be converted to `models::AddServerIp201Response`"
600                )));
601            }
602            ContentType::Unsupported(unknown_type) => {
603                return Err(Error::from(serde_json::Error::custom(format!(
604                    "Received `{unknown_type}` content type response that cannot be converted to `models::AddServerIp201Response`"
605                ))));
606            }
607        }
608    } else {
609        let content = resp.text().await?;
610        let entity: Option<AddServerIpError> = serde_json::from_str(&content).ok();
611        Err(Error::ResponseError(ResponseContent {
612            status,
613            content,
614            entity
615        }))
616    }
617}
618
619/// Чтобы клонировать сервер, отправьте POST-запрос на
620/// `/api/v1/servers/{server_id}/clone`.
621pub async fn clone_server(
622    configuration: &configuration::Configuration,
623    server_id: i32
624) -> Result<models::CreateServer201Response, Error<CloneServerError>> {
625    // add a prefix to parameters to efficiently prevent name collisions
626    let p_path_server_id = server_id;
627
628    let uri_str = format!(
629        "{}/api/v1/servers/{server_id}/clone",
630        configuration.base_path,
631        server_id = p_path_server_id
632    );
633    let mut req_builder = configuration
634        .client
635        .request(reqwest::Method::POST, &uri_str);
636
637    if let Some(ref user_agent) = configuration.user_agent {
638        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
639    }
640    if let Some(ref token) = configuration.bearer_access_token {
641        req_builder = req_builder.bearer_auth(token.to_owned());
642    };
643
644    let req = req_builder.build()?;
645    let resp = configuration.client.execute(req).await?;
646
647    let status = resp.status();
648    let content_type = resp
649        .headers()
650        .get("content-type")
651        .and_then(|v| v.to_str().ok())
652        .unwrap_or("application/octet-stream");
653    let content_type = super::ContentType::from(content_type);
654
655    if !status.is_client_error() && !status.is_server_error() {
656        let content = resp.text().await?;
657        match content_type {
658            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
659            ContentType::Text => {
660                return Err(Error::from(serde_json::Error::custom(
661                    "Received `text/plain` content type response that cannot be converted to `models::CreateServer201Response`"
662                )));
663            }
664            ContentType::Unsupported(unknown_type) => {
665                return Err(Error::from(serde_json::Error::custom(format!(
666                    "Received `{unknown_type}` content type response that cannot be converted to `models::CreateServer201Response`"
667                ))));
668            }
669        }
670    } else {
671        let content = resp.text().await?;
672        let entity: Option<CloneServerError> = serde_json::from_str(&content).ok();
673        Err(Error::ResponseError(ResponseContent {
674            status,
675            content,
676            entity
677        }))
678    }
679}
680
681/// Чтобы создать сервер, отправьте POST-запрос в `api/v1/servers`, задав
682/// необходимые атрибуты. Обязательно должен присутствовать один из параметров
683/// `configuration` или `preset_id`, а также `image_id` или `os_id`.  Cервер
684/// будет создан с использованием предоставленной информации. Тело ответа будет
685/// содержать объект JSON с информацией о созданном сервере.
686pub async fn create_server(
687    configuration: &configuration::Configuration,
688    create_server: models::CreateServer
689) -> Result<models::CreateServer201Response, Error<CreateServerError>> {
690    // add a prefix to parameters to efficiently prevent name collisions
691    let p_body_create_server = create_server;
692
693    let uri_str = format!("{}/api/v1/servers", configuration.base_path);
694    let mut req_builder = configuration
695        .client
696        .request(reqwest::Method::POST, &uri_str);
697
698    if let Some(ref user_agent) = configuration.user_agent {
699        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
700    }
701    if let Some(ref token) = configuration.bearer_access_token {
702        req_builder = req_builder.bearer_auth(token.to_owned());
703    };
704    req_builder = req_builder.json(&p_body_create_server);
705
706    let req = req_builder.build()?;
707    let resp = configuration.client.execute(req).await?;
708
709    let status = resp.status();
710    let content_type = resp
711        .headers()
712        .get("content-type")
713        .and_then(|v| v.to_str().ok())
714        .unwrap_or("application/octet-stream");
715    let content_type = super::ContentType::from(content_type);
716
717    if !status.is_client_error() && !status.is_server_error() {
718        let content = resp.text().await?;
719        match content_type {
720            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
721            ContentType::Text => {
722                return Err(Error::from(serde_json::Error::custom(
723                    "Received `text/plain` content type response that cannot be converted to `models::CreateServer201Response`"
724                )));
725            }
726            ContentType::Unsupported(unknown_type) => {
727                return Err(Error::from(serde_json::Error::custom(format!(
728                    "Received `{unknown_type}` content type response that cannot be converted to `models::CreateServer201Response`"
729                ))));
730            }
731        }
732    } else {
733        let content = resp.text().await?;
734        let entity: Option<CreateServerError> = serde_json::from_str(&content).ok();
735        Err(Error::ResponseError(ResponseContent {
736            status,
737            content,
738            entity
739        }))
740    }
741}
742
743/// Чтобы создать диск сервера, отправьте POST-запрос на
744/// `/api/v1/servers/{server_id}/disks`. Системный диск создать нельзя.
745pub async fn create_server_disk(
746    configuration: &configuration::Configuration,
747    server_id: i32,
748    create_server_disk_request: Option<models::CreateServerDiskRequest>
749) -> Result<models::CreateServerDisk201Response, Error<CreateServerDiskError>> {
750    // add a prefix to parameters to efficiently prevent name collisions
751    let p_path_server_id = server_id;
752    let p_body_create_server_disk_request = create_server_disk_request;
753
754    let uri_str = format!(
755        "{}/api/v1/servers/{server_id}/disks",
756        configuration.base_path,
757        server_id = p_path_server_id
758    );
759    let mut req_builder = configuration
760        .client
761        .request(reqwest::Method::POST, &uri_str);
762
763    if let Some(ref user_agent) = configuration.user_agent {
764        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
765    }
766    if let Some(ref token) = configuration.bearer_access_token {
767        req_builder = req_builder.bearer_auth(token.to_owned());
768    };
769    req_builder = req_builder.json(&p_body_create_server_disk_request);
770
771    let req = req_builder.build()?;
772    let resp = configuration.client.execute(req).await?;
773
774    let status = resp.status();
775    let content_type = resp
776        .headers()
777        .get("content-type")
778        .and_then(|v| v.to_str().ok())
779        .unwrap_or("application/octet-stream");
780    let content_type = super::ContentType::from(content_type);
781
782    if !status.is_client_error() && !status.is_server_error() {
783        let content = resp.text().await?;
784        match content_type {
785            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
786            ContentType::Text => {
787                return Err(Error::from(serde_json::Error::custom(
788                    "Received `text/plain` content type response that cannot be converted to `models::CreateServerDisk201Response`"
789                )));
790            }
791            ContentType::Unsupported(unknown_type) => {
792                return Err(Error::from(serde_json::Error::custom(format!(
793                    "Received `{unknown_type}` content type response that cannot be converted to `models::CreateServerDisk201Response`"
794                ))));
795            }
796        }
797    } else {
798        let content = resp.text().await?;
799        let entity: Option<CreateServerDiskError> = serde_json::from_str(&content).ok();
800        Err(Error::ResponseError(ResponseContent {
801            status,
802            content,
803            entity
804        }))
805    }
806}
807
808/// Чтобы создать бэкап диска сервера, отправьте POST-запрос на
809/// `/api/v1/servers/{server_id}/disks/{disk_id}/backups`.   Тело ответа будет
810/// представлять собой объект JSON с ключом `backup`.
811pub async fn create_server_disk_backup(
812    configuration: &configuration::Configuration,
813    server_id: i32,
814    disk_id: i32,
815    create_server_disk_backup_request: Option<models::CreateServerDiskBackupRequest>
816) -> Result<models::CreateServerDiskBackup201Response, Error<CreateServerDiskBackupError>> {
817    // add a prefix to parameters to efficiently prevent name collisions
818    let p_path_server_id = server_id;
819    let p_path_disk_id = disk_id;
820    let p_body_create_server_disk_backup_request = create_server_disk_backup_request;
821
822    let uri_str = format!(
823        "{}/api/v1/servers/{server_id}/disks/{disk_id}/backups",
824        configuration.base_path,
825        server_id = p_path_server_id,
826        disk_id = p_path_disk_id
827    );
828    let mut req_builder = configuration
829        .client
830        .request(reqwest::Method::POST, &uri_str);
831
832    if let Some(ref user_agent) = configuration.user_agent {
833        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
834    }
835    if let Some(ref token) = configuration.bearer_access_token {
836        req_builder = req_builder.bearer_auth(token.to_owned());
837    };
838    req_builder = req_builder.json(&p_body_create_server_disk_backup_request);
839
840    let req = req_builder.build()?;
841    let resp = configuration.client.execute(req).await?;
842
843    let status = resp.status();
844    let content_type = resp
845        .headers()
846        .get("content-type")
847        .and_then(|v| v.to_str().ok())
848        .unwrap_or("application/octet-stream");
849    let content_type = super::ContentType::from(content_type);
850
851    if !status.is_client_error() && !status.is_server_error() {
852        let content = resp.text().await?;
853        match content_type {
854            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
855            ContentType::Text => {
856                return Err(Error::from(serde_json::Error::custom(
857                    "Received `text/plain` content type response that cannot be converted to `models::CreateServerDiskBackup201Response`"
858                )));
859            }
860            ContentType::Unsupported(unknown_type) => {
861                return Err(Error::from(serde_json::Error::custom(format!(
862                    "Received `{unknown_type}` content type response that cannot be converted to `models::CreateServerDiskBackup201Response`"
863                ))));
864            }
865        }
866    } else {
867        let content = resp.text().await?;
868        let entity: Option<CreateServerDiskBackupError> = serde_json::from_str(&content).ok();
869        Err(Error::ResponseError(ResponseContent {
870            status,
871            content,
872            entity
873        }))
874    }
875}
876
877/// Чтобы удалить сервер, отправьте запрос DELETE в
878/// `/api/v1/servers/{server_id}`.\\  Обратите внимание, если на аккаунте
879/// включено удаление серверов по смс, то вернется ошибка 423.
880pub async fn delete_server(
881    configuration: &configuration::Configuration,
882    server_id: i32,
883    hash: Option<&str>,
884    code: Option<&str>
885) -> Result<models::DeleteServer200Response, Error<DeleteServerError>> {
886    // add a prefix to parameters to efficiently prevent name collisions
887    let p_path_server_id = server_id;
888    let p_query_hash = hash;
889    let p_query_code = code;
890
891    let uri_str = format!(
892        "{}/api/v1/servers/{server_id}",
893        configuration.base_path,
894        server_id = p_path_server_id
895    );
896    let mut req_builder = configuration
897        .client
898        .request(reqwest::Method::DELETE, &uri_str);
899
900    if let Some(ref param_value) = p_query_hash {
901        req_builder = req_builder.query(&[("hash", &param_value.to_string())]);
902    }
903    if let Some(ref param_value) = p_query_code {
904        req_builder = req_builder.query(&[("code", &param_value.to_string())]);
905    }
906    if let Some(ref user_agent) = configuration.user_agent {
907        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
908    }
909    if let Some(ref token) = configuration.bearer_access_token {
910        req_builder = req_builder.bearer_auth(token.to_owned());
911    };
912
913    let req = req_builder.build()?;
914    let resp = configuration.client.execute(req).await?;
915
916    let status = resp.status();
917    let content_type = resp
918        .headers()
919        .get("content-type")
920        .and_then(|v| v.to_str().ok())
921        .unwrap_or("application/octet-stream");
922    let content_type = super::ContentType::from(content_type);
923
924    if !status.is_client_error() && !status.is_server_error() {
925        let content = resp.text().await?;
926        match content_type {
927            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
928            ContentType::Text => {
929                return Err(Error::from(serde_json::Error::custom(
930                    "Received `text/plain` content type response that cannot be converted to `models::DeleteServer200Response`"
931                )));
932            }
933            ContentType::Unsupported(unknown_type) => {
934                return Err(Error::from(serde_json::Error::custom(format!(
935                    "Received `{unknown_type}` content type response that cannot be converted to `models::DeleteServer200Response`"
936                ))));
937            }
938        }
939    } else {
940        let content = resp.text().await?;
941        let entity: Option<DeleteServerError> = serde_json::from_str(&content).ok();
942        Err(Error::ResponseError(ResponseContent {
943            status,
944            content,
945            entity
946        }))
947    }
948}
949
950/// Чтобы удалить диск сервера, отправьте DELETE-запрос на
951/// `/api/v1/servers/{server_id}/disks/{disk_id}`. Нельзя удалять системный
952/// диск.
953pub async fn delete_server_disk(
954    configuration: &configuration::Configuration,
955    server_id: i32,
956    disk_id: i32
957) -> Result<(), Error<DeleteServerDiskError>> {
958    // add a prefix to parameters to efficiently prevent name collisions
959    let p_path_server_id = server_id;
960    let p_path_disk_id = disk_id;
961
962    let uri_str = format!(
963        "{}/api/v1/servers/{server_id}/disks/{disk_id}",
964        configuration.base_path,
965        server_id = p_path_server_id,
966        disk_id = p_path_disk_id
967    );
968    let mut req_builder = configuration
969        .client
970        .request(reqwest::Method::DELETE, &uri_str);
971
972    if let Some(ref user_agent) = configuration.user_agent {
973        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
974    }
975    if let Some(ref token) = configuration.bearer_access_token {
976        req_builder = req_builder.bearer_auth(token.to_owned());
977    };
978
979    let req = req_builder.build()?;
980    let resp = configuration.client.execute(req).await?;
981
982    let status = resp.status();
983
984    if !status.is_client_error() && !status.is_server_error() {
985        Ok(())
986    } else {
987        let content = resp.text().await?;
988        let entity: Option<DeleteServerDiskError> = serde_json::from_str(&content).ok();
989        Err(Error::ResponseError(ResponseContent {
990            status,
991            content,
992            entity
993        }))
994    }
995}
996
997/// Чтобы удалить бэкап диска сервера, отправьте DELETE-запрос на
998/// `/api/v1/servers/{server_id}/disks/{disk_id}/backups/{backup_id}`.
999pub async fn delete_server_disk_backup(
1000    configuration: &configuration::Configuration,
1001    server_id: i32,
1002    disk_id: i32,
1003    backup_id: i32
1004) -> Result<(), Error<DeleteServerDiskBackupError>> {
1005    // add a prefix to parameters to efficiently prevent name collisions
1006    let p_path_server_id = server_id;
1007    let p_path_disk_id = disk_id;
1008    let p_path_backup_id = backup_id;
1009
1010    let uri_str = format!(
1011        "{}/api/v1/servers/{server_id}/disks/{disk_id}/backups/{backup_id}",
1012        configuration.base_path,
1013        server_id = p_path_server_id,
1014        disk_id = p_path_disk_id,
1015        backup_id = p_path_backup_id
1016    );
1017    let mut req_builder = configuration
1018        .client
1019        .request(reqwest::Method::DELETE, &uri_str);
1020
1021    if let Some(ref user_agent) = configuration.user_agent {
1022        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1023    }
1024    if let Some(ref token) = configuration.bearer_access_token {
1025        req_builder = req_builder.bearer_auth(token.to_owned());
1026    };
1027
1028    let req = req_builder.build()?;
1029    let resp = configuration.client.execute(req).await?;
1030
1031    let status = resp.status();
1032
1033    if !status.is_client_error() && !status.is_server_error() {
1034        Ok(())
1035    } else {
1036        let content = resp.text().await?;
1037        let entity: Option<DeleteServerDiskBackupError> = serde_json::from_str(&content).ok();
1038        Err(Error::ResponseError(ResponseContent {
1039            status,
1040            content,
1041            entity
1042        }))
1043    }
1044}
1045
1046/// Чтобы удалить IP-адрес сервера, отправьте DELETE-запрос на
1047/// `/api/v1/servers/{server_id}/ips`. Нельзя удалить основной IP-адрес
1048pub async fn delete_server_ip(
1049    configuration: &configuration::Configuration,
1050    server_id: i32,
1051    delete_server_ip_request: models::DeleteServerIpRequest
1052) -> Result<(), Error<DeleteServerIpError>> {
1053    // add a prefix to parameters to efficiently prevent name collisions
1054    let p_path_server_id = server_id;
1055    let p_body_delete_server_ip_request = delete_server_ip_request;
1056
1057    let uri_str = format!(
1058        "{}/api/v1/servers/{server_id}/ips",
1059        configuration.base_path,
1060        server_id = p_path_server_id
1061    );
1062    let mut req_builder = configuration
1063        .client
1064        .request(reqwest::Method::DELETE, &uri_str);
1065
1066    if let Some(ref user_agent) = configuration.user_agent {
1067        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1068    }
1069    if let Some(ref token) = configuration.bearer_access_token {
1070        req_builder = req_builder.bearer_auth(token.to_owned());
1071    };
1072    req_builder = req_builder.json(&p_body_delete_server_ip_request);
1073
1074    let req = req_builder.build()?;
1075    let resp = configuration.client.execute(req).await?;
1076
1077    let status = resp.status();
1078
1079    if !status.is_client_error() && !status.is_server_error() {
1080        Ok(())
1081    } else {
1082        let content = resp.text().await?;
1083        let entity: Option<DeleteServerIpError> = serde_json::from_str(&content).ok();
1084        Err(Error::ResponseError(ResponseContent {
1085            status,
1086            content,
1087            entity
1088        }))
1089    }
1090}
1091
1092/// Чтобы получить список всех конфигураторов серверов, отправьте GET-запрос на
1093/// `/api/v1/configurator/servers`.   Тело ответа будет представлять собой
1094/// объект JSON с ключом `server_configurators`.
1095pub async fn get_configurators(
1096    configuration: &configuration::Configuration
1097) -> Result<models::GetConfigurators200Response, Error<GetConfiguratorsError>> {
1098    let uri_str = format!("{}/api/v1/configurator/servers", configuration.base_path);
1099    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1100
1101    if let Some(ref user_agent) = configuration.user_agent {
1102        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1103    }
1104    if let Some(ref token) = configuration.bearer_access_token {
1105        req_builder = req_builder.bearer_auth(token.to_owned());
1106    };
1107
1108    let req = req_builder.build()?;
1109    let resp = configuration.client.execute(req).await?;
1110
1111    let status = resp.status();
1112    let content_type = resp
1113        .headers()
1114        .get("content-type")
1115        .and_then(|v| v.to_str().ok())
1116        .unwrap_or("application/octet-stream");
1117    let content_type = super::ContentType::from(content_type);
1118
1119    if !status.is_client_error() && !status.is_server_error() {
1120        let content = resp.text().await?;
1121        match content_type {
1122            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1123            ContentType::Text => {
1124                return Err(Error::from(serde_json::Error::custom(
1125                    "Received `text/plain` content type response that cannot be converted to `models::GetConfigurators200Response`"
1126                )));
1127            }
1128            ContentType::Unsupported(unknown_type) => {
1129                return Err(Error::from(serde_json::Error::custom(format!(
1130                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetConfigurators200Response`"
1131                ))));
1132            }
1133        }
1134    } else {
1135        let content = resp.text().await?;
1136        let entity: Option<GetConfiguratorsError> = serde_json::from_str(&content).ok();
1137        Err(Error::ResponseError(ResponseContent {
1138            status,
1139            content,
1140            entity
1141        }))
1142    }
1143}
1144
1145/// Чтобы получить список всех операционных систем, отправьте GET-запрос на
1146/// `/api/v1/os/servers`.   Тело ответа будет представлять собой объект JSON с
1147/// ключом `servers_os`.
1148pub async fn get_os_list(
1149    configuration: &configuration::Configuration
1150) -> Result<models::GetOsList200Response, Error<GetOsListError>> {
1151    let uri_str = format!("{}/api/v1/os/servers", configuration.base_path);
1152    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1153
1154    if let Some(ref user_agent) = configuration.user_agent {
1155        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1156    }
1157    if let Some(ref token) = configuration.bearer_access_token {
1158        req_builder = req_builder.bearer_auth(token.to_owned());
1159    };
1160
1161    let req = req_builder.build()?;
1162    let resp = configuration.client.execute(req).await?;
1163
1164    let status = resp.status();
1165    let content_type = resp
1166        .headers()
1167        .get("content-type")
1168        .and_then(|v| v.to_str().ok())
1169        .unwrap_or("application/octet-stream");
1170    let content_type = super::ContentType::from(content_type);
1171
1172    if !status.is_client_error() && !status.is_server_error() {
1173        let content = resp.text().await?;
1174        match content_type {
1175            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1176            ContentType::Text => {
1177                return Err(Error::from(serde_json::Error::custom(
1178                    "Received `text/plain` content type response that cannot be converted to `models::GetOsList200Response`"
1179                )));
1180            }
1181            ContentType::Unsupported(unknown_type) => {
1182                return Err(Error::from(serde_json::Error::custom(format!(
1183                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetOsList200Response`"
1184                ))));
1185            }
1186        }
1187    } else {
1188        let content = resp.text().await?;
1189        let entity: Option<GetOsListError> = serde_json::from_str(&content).ok();
1190        Err(Error::ResponseError(ResponseContent {
1191            status,
1192            content,
1193            entity
1194        }))
1195    }
1196}
1197
1198/// Чтобы получить сервер, отправьте запрос GET в `/api/v1/servers/{server_id}`.
1199pub async fn get_server(
1200    configuration: &configuration::Configuration,
1201    server_id: i32
1202) -> Result<models::CreateServer201Response, Error<GetServerError>> {
1203    // add a prefix to parameters to efficiently prevent name collisions
1204    let p_path_server_id = server_id;
1205
1206    let uri_str = format!(
1207        "{}/api/v1/servers/{server_id}",
1208        configuration.base_path,
1209        server_id = p_path_server_id
1210    );
1211    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1212
1213    if let Some(ref user_agent) = configuration.user_agent {
1214        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1215    }
1216    if let Some(ref token) = configuration.bearer_access_token {
1217        req_builder = req_builder.bearer_auth(token.to_owned());
1218    };
1219
1220    let req = req_builder.build()?;
1221    let resp = configuration.client.execute(req).await?;
1222
1223    let status = resp.status();
1224    let content_type = resp
1225        .headers()
1226        .get("content-type")
1227        .and_then(|v| v.to_str().ok())
1228        .unwrap_or("application/octet-stream");
1229    let content_type = super::ContentType::from(content_type);
1230
1231    if !status.is_client_error() && !status.is_server_error() {
1232        let content = resp.text().await?;
1233        match content_type {
1234            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1235            ContentType::Text => {
1236                return Err(Error::from(serde_json::Error::custom(
1237                    "Received `text/plain` content type response that cannot be converted to `models::CreateServer201Response`"
1238                )));
1239            }
1240            ContentType::Unsupported(unknown_type) => {
1241                return Err(Error::from(serde_json::Error::custom(format!(
1242                    "Received `{unknown_type}` content type response that cannot be converted to `models::CreateServer201Response`"
1243                ))));
1244            }
1245        }
1246    } else {
1247        let content = resp.text().await?;
1248        let entity: Option<GetServerError> = serde_json::from_str(&content).ok();
1249        Err(Error::ResponseError(ResponseContent {
1250            status,
1251            content,
1252            entity
1253        }))
1254    }
1255}
1256
1257/// Чтобы получить диск сервера, отправьте GET-запрос на
1258/// `/api/v1/servers/{server_id}/disks/{disk_id}`.
1259pub async fn get_server_disk(
1260    configuration: &configuration::Configuration,
1261    server_id: i32,
1262    disk_id: i32
1263) -> Result<models::CreateServerDisk201Response, Error<GetServerDiskError>> {
1264    // add a prefix to parameters to efficiently prevent name collisions
1265    let p_path_server_id = server_id;
1266    let p_path_disk_id = disk_id;
1267
1268    let uri_str = format!(
1269        "{}/api/v1/servers/{server_id}/disks/{disk_id}",
1270        configuration.base_path,
1271        server_id = p_path_server_id,
1272        disk_id = p_path_disk_id
1273    );
1274    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1275
1276    if let Some(ref user_agent) = configuration.user_agent {
1277        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1278    }
1279    if let Some(ref token) = configuration.bearer_access_token {
1280        req_builder = req_builder.bearer_auth(token.to_owned());
1281    };
1282
1283    let req = req_builder.build()?;
1284    let resp = configuration.client.execute(req).await?;
1285
1286    let status = resp.status();
1287    let content_type = resp
1288        .headers()
1289        .get("content-type")
1290        .and_then(|v| v.to_str().ok())
1291        .unwrap_or("application/octet-stream");
1292    let content_type = super::ContentType::from(content_type);
1293
1294    if !status.is_client_error() && !status.is_server_error() {
1295        let content = resp.text().await?;
1296        match content_type {
1297            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1298            ContentType::Text => {
1299                return Err(Error::from(serde_json::Error::custom(
1300                    "Received `text/plain` content type response that cannot be converted to `models::CreateServerDisk201Response`"
1301                )));
1302            }
1303            ContentType::Unsupported(unknown_type) => {
1304                return Err(Error::from(serde_json::Error::custom(format!(
1305                    "Received `{unknown_type}` content type response that cannot be converted to `models::CreateServerDisk201Response`"
1306                ))));
1307            }
1308        }
1309    } else {
1310        let content = resp.text().await?;
1311        let entity: Option<GetServerDiskError> = serde_json::from_str(&content).ok();
1312        Err(Error::ResponseError(ResponseContent {
1313            status,
1314            content,
1315            entity
1316        }))
1317    }
1318}
1319
1320/// Чтобы полученить настройки автобэкапов диска сервера, отправьте GET-запрос
1321/// на `/api/v1/servers/{server_id}/disks/{disk_id}/auto-backups`.
1322pub async fn get_server_disk_auto_backup_settings(
1323    configuration: &configuration::Configuration,
1324    server_id: i32,
1325    disk_id: i32
1326) -> Result<
1327    models::GetServerDiskAutoBackupSettings200Response,
1328    Error<GetServerDiskAutoBackupSettingsError>
1329> {
1330    // add a prefix to parameters to efficiently prevent name collisions
1331    let p_path_server_id = server_id;
1332    let p_path_disk_id = disk_id;
1333
1334    let uri_str = format!(
1335        "{}/api/v1/servers/{server_id}/disks/{disk_id}/auto-backups",
1336        configuration.base_path,
1337        server_id = p_path_server_id,
1338        disk_id = p_path_disk_id
1339    );
1340    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1341
1342    if let Some(ref user_agent) = configuration.user_agent {
1343        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1344    }
1345    if let Some(ref token) = configuration.bearer_access_token {
1346        req_builder = req_builder.bearer_auth(token.to_owned());
1347    };
1348
1349    let req = req_builder.build()?;
1350    let resp = configuration.client.execute(req).await?;
1351
1352    let status = resp.status();
1353    let content_type = resp
1354        .headers()
1355        .get("content-type")
1356        .and_then(|v| v.to_str().ok())
1357        .unwrap_or("application/octet-stream");
1358    let content_type = super::ContentType::from(content_type);
1359
1360    if !status.is_client_error() && !status.is_server_error() {
1361        let content = resp.text().await?;
1362        match content_type {
1363            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1364            ContentType::Text => {
1365                return Err(Error::from(serde_json::Error::custom(
1366                    "Received `text/plain` content type response that cannot be converted to `models::GetServerDiskAutoBackupSettings200Response`"
1367                )));
1368            }
1369            ContentType::Unsupported(unknown_type) => {
1370                return Err(Error::from(serde_json::Error::custom(format!(
1371                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServerDiskAutoBackupSettings200Response`"
1372                ))));
1373            }
1374        }
1375    } else {
1376        let content = resp.text().await?;
1377        let entity: Option<GetServerDiskAutoBackupSettingsError> =
1378            serde_json::from_str(&content).ok();
1379        Err(Error::ResponseError(ResponseContent {
1380            status,
1381            content,
1382            entity
1383        }))
1384    }
1385}
1386
1387/// Чтобы получить бэкап диска сервера, отправьте GET-запрос на
1388/// `/api/v1/servers/{server_id}/disks/{disk_id}/backups/{backup_id}`.   Тело
1389/// ответа будет представлять собой объект JSON с ключом `backup`.
1390pub async fn get_server_disk_backup(
1391    configuration: &configuration::Configuration,
1392    server_id: i32,
1393    disk_id: i32,
1394    backup_id: i32
1395) -> Result<models::GetServerDiskBackup200Response, Error<GetServerDiskBackupError>> {
1396    // add a prefix to parameters to efficiently prevent name collisions
1397    let p_path_server_id = server_id;
1398    let p_path_disk_id = disk_id;
1399    let p_path_backup_id = backup_id;
1400
1401    let uri_str = format!(
1402        "{}/api/v1/servers/{server_id}/disks/{disk_id}/backups/{backup_id}",
1403        configuration.base_path,
1404        server_id = p_path_server_id,
1405        disk_id = p_path_disk_id,
1406        backup_id = p_path_backup_id
1407    );
1408    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1409
1410    if let Some(ref user_agent) = configuration.user_agent {
1411        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1412    }
1413    if let Some(ref token) = configuration.bearer_access_token {
1414        req_builder = req_builder.bearer_auth(token.to_owned());
1415    };
1416
1417    let req = req_builder.build()?;
1418    let resp = configuration.client.execute(req).await?;
1419
1420    let status = resp.status();
1421    let content_type = resp
1422        .headers()
1423        .get("content-type")
1424        .and_then(|v| v.to_str().ok())
1425        .unwrap_or("application/octet-stream");
1426    let content_type = super::ContentType::from(content_type);
1427
1428    if !status.is_client_error() && !status.is_server_error() {
1429        let content = resp.text().await?;
1430        match content_type {
1431            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1432            ContentType::Text => {
1433                return Err(Error::from(serde_json::Error::custom(
1434                    "Received `text/plain` content type response that cannot be converted to `models::GetServerDiskBackup200Response`"
1435                )));
1436            }
1437            ContentType::Unsupported(unknown_type) => {
1438                return Err(Error::from(serde_json::Error::custom(format!(
1439                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServerDiskBackup200Response`"
1440                ))));
1441            }
1442        }
1443    } else {
1444        let content = resp.text().await?;
1445        let entity: Option<GetServerDiskBackupError> = serde_json::from_str(&content).ok();
1446        Err(Error::ResponseError(ResponseContent {
1447            status,
1448            content,
1449            entity
1450        }))
1451    }
1452}
1453
1454/// Чтобы получить список бэкапов диска сервера, отправьте GET-запрос на
1455/// `/api/v1/servers/{server_id}/disks/{disk_id}/backups`.   Тело ответа будет
1456/// представлять собой объект JSON с ключом `backups`.
1457pub async fn get_server_disk_backups(
1458    configuration: &configuration::Configuration,
1459    server_id: i32,
1460    disk_id: i32
1461) -> Result<models::GetServerDiskBackups200Response, Error<GetServerDiskBackupsError>> {
1462    // add a prefix to parameters to efficiently prevent name collisions
1463    let p_path_server_id = server_id;
1464    let p_path_disk_id = disk_id;
1465
1466    let uri_str = format!(
1467        "{}/api/v1/servers/{server_id}/disks/{disk_id}/backups",
1468        configuration.base_path,
1469        server_id = p_path_server_id,
1470        disk_id = p_path_disk_id
1471    );
1472    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1473
1474    if let Some(ref user_agent) = configuration.user_agent {
1475        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1476    }
1477    if let Some(ref token) = configuration.bearer_access_token {
1478        req_builder = req_builder.bearer_auth(token.to_owned());
1479    };
1480
1481    let req = req_builder.build()?;
1482    let resp = configuration.client.execute(req).await?;
1483
1484    let status = resp.status();
1485    let content_type = resp
1486        .headers()
1487        .get("content-type")
1488        .and_then(|v| v.to_str().ok())
1489        .unwrap_or("application/octet-stream");
1490    let content_type = super::ContentType::from(content_type);
1491
1492    if !status.is_client_error() && !status.is_server_error() {
1493        let content = resp.text().await?;
1494        match content_type {
1495            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1496            ContentType::Text => {
1497                return Err(Error::from(serde_json::Error::custom(
1498                    "Received `text/plain` content type response that cannot be converted to `models::GetServerDiskBackups200Response`"
1499                )));
1500            }
1501            ContentType::Unsupported(unknown_type) => {
1502                return Err(Error::from(serde_json::Error::custom(format!(
1503                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServerDiskBackups200Response`"
1504                ))));
1505            }
1506        }
1507    } else {
1508        let content = resp.text().await?;
1509        let entity: Option<GetServerDiskBackupsError> = serde_json::from_str(&content).ok();
1510        Err(Error::ResponseError(ResponseContent {
1511            status,
1512            content,
1513            entity
1514        }))
1515    }
1516}
1517
1518/// Чтобы получить список дисков сервера, отправьте GET-запрос на
1519/// `/api/v1/servers/{server_id}/disks`.
1520pub async fn get_server_disks(
1521    configuration: &configuration::Configuration,
1522    server_id: i32
1523) -> Result<models::GetServerDisks200Response, Error<GetServerDisksError>> {
1524    // add a prefix to parameters to efficiently prevent name collisions
1525    let p_path_server_id = server_id;
1526
1527    let uri_str = format!(
1528        "{}/api/v1/servers/{server_id}/disks",
1529        configuration.base_path,
1530        server_id = p_path_server_id
1531    );
1532    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1533
1534    if let Some(ref user_agent) = configuration.user_agent {
1535        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1536    }
1537    if let Some(ref token) = configuration.bearer_access_token {
1538        req_builder = req_builder.bearer_auth(token.to_owned());
1539    };
1540
1541    let req = req_builder.build()?;
1542    let resp = configuration.client.execute(req).await?;
1543
1544    let status = resp.status();
1545    let content_type = resp
1546        .headers()
1547        .get("content-type")
1548        .and_then(|v| v.to_str().ok())
1549        .unwrap_or("application/octet-stream");
1550    let content_type = super::ContentType::from(content_type);
1551
1552    if !status.is_client_error() && !status.is_server_error() {
1553        let content = resp.text().await?;
1554        match content_type {
1555            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1556            ContentType::Text => {
1557                return Err(Error::from(serde_json::Error::custom(
1558                    "Received `text/plain` content type response that cannot be converted to `models::GetServerDisks200Response`"
1559                )));
1560            }
1561            ContentType::Unsupported(unknown_type) => {
1562                return Err(Error::from(serde_json::Error::custom(format!(
1563                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServerDisks200Response`"
1564                ))));
1565            }
1566        }
1567    } else {
1568        let content = resp.text().await?;
1569        let entity: Option<GetServerDisksError> = serde_json::from_str(&content).ok();
1570        Err(Error::ResponseError(ResponseContent {
1571            status,
1572            content,
1573            entity
1574        }))
1575    }
1576}
1577
1578/// Чтобы получить список IP-адресов сервера, отправьте GET-запрос на
1579/// `/api/v1/servers/{server_id}/ips`. \\  На данный момент IPv6 доступны только
1580/// для локации `ru-1`.
1581pub async fn get_server_ips(
1582    configuration: &configuration::Configuration,
1583    server_id: i32
1584) -> Result<models::GetServerIps200Response, Error<GetServerIpsError>> {
1585    // add a prefix to parameters to efficiently prevent name collisions
1586    let p_path_server_id = server_id;
1587
1588    let uri_str = format!(
1589        "{}/api/v1/servers/{server_id}/ips",
1590        configuration.base_path,
1591        server_id = p_path_server_id
1592    );
1593    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1594
1595    if let Some(ref user_agent) = configuration.user_agent {
1596        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1597    }
1598    if let Some(ref token) = configuration.bearer_access_token {
1599        req_builder = req_builder.bearer_auth(token.to_owned());
1600    };
1601
1602    let req = req_builder.build()?;
1603    let resp = configuration.client.execute(req).await?;
1604
1605    let status = resp.status();
1606    let content_type = resp
1607        .headers()
1608        .get("content-type")
1609        .and_then(|v| v.to_str().ok())
1610        .unwrap_or("application/octet-stream");
1611    let content_type = super::ContentType::from(content_type);
1612
1613    if !status.is_client_error() && !status.is_server_error() {
1614        let content = resp.text().await?;
1615        match content_type {
1616            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1617            ContentType::Text => {
1618                return Err(Error::from(serde_json::Error::custom(
1619                    "Received `text/plain` content type response that cannot be converted to `models::GetServerIps200Response`"
1620                )));
1621            }
1622            ContentType::Unsupported(unknown_type) => {
1623                return Err(Error::from(serde_json::Error::custom(format!(
1624                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServerIps200Response`"
1625                ))));
1626            }
1627        }
1628    } else {
1629        let content = resp.text().await?;
1630        let entity: Option<GetServerIpsError> = serde_json::from_str(&content).ok();
1631        Err(Error::ResponseError(ResponseContent {
1632            status,
1633            content,
1634            entity
1635        }))
1636    }
1637}
1638
1639/// Чтобы получить список логов сервера, отправьте GET-запрос на
1640/// `/api/v1/servers/{server_id}/logs`.
1641pub async fn get_server_logs(
1642    configuration: &configuration::Configuration,
1643    server_id: i32,
1644    limit: Option<i32>,
1645    offset: Option<i32>,
1646    order: Option<&str>
1647) -> Result<models::GetServerLogs200Response, Error<GetServerLogsError>> {
1648    // add a prefix to parameters to efficiently prevent name collisions
1649    let p_path_server_id = server_id;
1650    let p_query_limit = limit;
1651    let p_query_offset = offset;
1652    let p_query_order = order;
1653
1654    let uri_str = format!(
1655        "{}/api/v1/servers/{server_id}/logs",
1656        configuration.base_path,
1657        server_id = p_path_server_id
1658    );
1659    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1660
1661    if let Some(ref param_value) = p_query_limit {
1662        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
1663    }
1664    if let Some(ref param_value) = p_query_offset {
1665        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
1666    }
1667    if let Some(ref param_value) = p_query_order {
1668        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
1669    }
1670    if let Some(ref user_agent) = configuration.user_agent {
1671        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1672    }
1673    if let Some(ref token) = configuration.bearer_access_token {
1674        req_builder = req_builder.bearer_auth(token.to_owned());
1675    };
1676
1677    let req = req_builder.build()?;
1678    let resp = configuration.client.execute(req).await?;
1679
1680    let status = resp.status();
1681    let content_type = resp
1682        .headers()
1683        .get("content-type")
1684        .and_then(|v| v.to_str().ok())
1685        .unwrap_or("application/octet-stream");
1686    let content_type = super::ContentType::from(content_type);
1687
1688    if !status.is_client_error() && !status.is_server_error() {
1689        let content = resp.text().await?;
1690        match content_type {
1691            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1692            ContentType::Text => {
1693                return Err(Error::from(serde_json::Error::custom(
1694                    "Received `text/plain` content type response that cannot be converted to `models::GetServerLogs200Response`"
1695                )));
1696            }
1697            ContentType::Unsupported(unknown_type) => {
1698                return Err(Error::from(serde_json::Error::custom(format!(
1699                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServerLogs200Response`"
1700                ))));
1701            }
1702        }
1703    } else {
1704        let content = resp.text().await?;
1705        let entity: Option<GetServerLogsError> = serde_json::from_str(&content).ok();
1706        Err(Error::ResponseError(ResponseContent {
1707            status,
1708            content,
1709            entity
1710        }))
1711    }
1712}
1713
1714/// Чтобы получить статистику сервера, отправьте GET-запрос на
1715/// `/api/v1/servers/{server_id}/statistics`.
1716#[deprecated]
1717pub async fn get_server_statistics(
1718    configuration: &configuration::Configuration,
1719    server_id: i32,
1720    date_from: &str,
1721    date_to: &str
1722) -> Result<models::GetServerStatistics200Response, Error<GetServerStatisticsError>> {
1723    // add a prefix to parameters to efficiently prevent name collisions
1724    let p_path_server_id = server_id;
1725    let p_query_date_from = date_from;
1726    let p_query_date_to = date_to;
1727
1728    let uri_str = format!(
1729        "{}/api/v1/servers/{server_id}/statistics",
1730        configuration.base_path,
1731        server_id = p_path_server_id
1732    );
1733    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1734
1735    req_builder = req_builder.query(&[("date_from", &p_query_date_from.to_string())]);
1736    req_builder = req_builder.query(&[("date_to", &p_query_date_to.to_string())]);
1737    if let Some(ref user_agent) = configuration.user_agent {
1738        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1739    }
1740    if let Some(ref token) = configuration.bearer_access_token {
1741        req_builder = req_builder.bearer_auth(token.to_owned());
1742    };
1743
1744    let req = req_builder.build()?;
1745    let resp = configuration.client.execute(req).await?;
1746
1747    let status = resp.status();
1748    let content_type = resp
1749        .headers()
1750        .get("content-type")
1751        .and_then(|v| v.to_str().ok())
1752        .unwrap_or("application/octet-stream");
1753    let content_type = super::ContentType::from(content_type);
1754
1755    if !status.is_client_error() && !status.is_server_error() {
1756        let content = resp.text().await?;
1757        match content_type {
1758            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1759            ContentType::Text => {
1760                return Err(Error::from(serde_json::Error::custom(
1761                    "Received `text/plain` content type response that cannot be converted to `models::GetServerStatistics200Response`"
1762                )));
1763            }
1764            ContentType::Unsupported(unknown_type) => {
1765                return Err(Error::from(serde_json::Error::custom(format!(
1766                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServerStatistics200Response`"
1767                ))));
1768            }
1769        }
1770    } else {
1771        let content = resp.text().await?;
1772        let entity: Option<GetServerStatisticsError> = serde_json::from_str(&content).ok();
1773        Err(Error::ResponseError(ResponseContent {
1774            status,
1775            content,
1776            entity
1777        }))
1778    }
1779}
1780
1781/// Чтобы получить статистику сервера, отправьте GET-запрос на
1782/// `/api/v1/servers/{server_id}/statistics/{time_from}/{period}/{keys}`.
1783pub async fn get_server_statistics_new(
1784    configuration: &configuration::Configuration,
1785    server_id: i32,
1786    time_from: &str,
1787    period: &str,
1788    keys: &str
1789) -> Result<models::GetServerStatisticsNew200Response, Error<GetServerStatisticsNewError>> {
1790    // add a prefix to parameters to efficiently prevent name collisions
1791    let p_path_server_id = server_id;
1792    let p_path_time_from = time_from;
1793    let p_path_period = period;
1794    let p_path_keys = keys;
1795
1796    let uri_str = format!(
1797        "{}/api/v1/servers/{server_id}/statistics/{time_from}/{period}/{keys}",
1798        configuration.base_path,
1799        server_id = p_path_server_id,
1800        time_from = crate::apis::urlencode(p_path_time_from),
1801        period = crate::apis::urlencode(p_path_period),
1802        keys = crate::apis::urlencode(p_path_keys)
1803    );
1804    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1805
1806    if let Some(ref user_agent) = configuration.user_agent {
1807        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1808    }
1809    if let Some(ref token) = configuration.bearer_access_token {
1810        req_builder = req_builder.bearer_auth(token.to_owned());
1811    };
1812
1813    let req = req_builder.build()?;
1814    let resp = configuration.client.execute(req).await?;
1815
1816    let status = resp.status();
1817    let content_type = resp
1818        .headers()
1819        .get("content-type")
1820        .and_then(|v| v.to_str().ok())
1821        .unwrap_or("application/octet-stream");
1822    let content_type = super::ContentType::from(content_type);
1823
1824    if !status.is_client_error() && !status.is_server_error() {
1825        let content = resp.text().await?;
1826        match content_type {
1827            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1828            ContentType::Text => {
1829                return Err(Error::from(serde_json::Error::custom(
1830                    "Received `text/plain` content type response that cannot be converted to `models::GetServerStatisticsNew200Response`"
1831                )));
1832            }
1833            ContentType::Unsupported(unknown_type) => {
1834                return Err(Error::from(serde_json::Error::custom(format!(
1835                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServerStatisticsNew200Response`"
1836                ))));
1837            }
1838        }
1839    } else {
1840        let content = resp.text().await?;
1841        let entity: Option<GetServerStatisticsNewError> = serde_json::from_str(&content).ok();
1842        Err(Error::ResponseError(ResponseContent {
1843            status,
1844            content,
1845            entity
1846        }))
1847    }
1848}
1849
1850/// Чтобы получить список серверов, отправьте GET-запрос на `/api/v1/servers`.
1851/// Тело ответа будет представлять собой объект JSON с ключом `servers`.
1852pub async fn get_servers(
1853    configuration: &configuration::Configuration,
1854    limit: Option<i32>,
1855    offset: Option<i32>
1856) -> Result<models::GetServers200Response, Error<GetServersError>> {
1857    // add a prefix to parameters to efficiently prevent name collisions
1858    let p_query_limit = limit;
1859    let p_query_offset = offset;
1860
1861    let uri_str = format!("{}/api/v1/servers", configuration.base_path);
1862    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1863
1864    if let Some(ref param_value) = p_query_limit {
1865        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
1866    }
1867    if let Some(ref param_value) = p_query_offset {
1868        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
1869    }
1870    if let Some(ref user_agent) = configuration.user_agent {
1871        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1872    }
1873    if let Some(ref token) = configuration.bearer_access_token {
1874        req_builder = req_builder.bearer_auth(token.to_owned());
1875    };
1876
1877    let req = req_builder.build()?;
1878    let resp = configuration.client.execute(req).await?;
1879
1880    let status = resp.status();
1881    let content_type = resp
1882        .headers()
1883        .get("content-type")
1884        .and_then(|v| v.to_str().ok())
1885        .unwrap_or("application/octet-stream");
1886    let content_type = super::ContentType::from(content_type);
1887
1888    if !status.is_client_error() && !status.is_server_error() {
1889        let content = resp.text().await?;
1890        match content_type {
1891            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1892            ContentType::Text => {
1893                return Err(Error::from(serde_json::Error::custom(
1894                    "Received `text/plain` content type response that cannot be converted to `models::GetServers200Response`"
1895                )));
1896            }
1897            ContentType::Unsupported(unknown_type) => {
1898                return Err(Error::from(serde_json::Error::custom(format!(
1899                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServers200Response`"
1900                ))));
1901            }
1902        }
1903    } else {
1904        let content = resp.text().await?;
1905        let entity: Option<GetServersError> = serde_json::from_str(&content).ok();
1906        Err(Error::ResponseError(ResponseContent {
1907            status,
1908            content,
1909            entity
1910        }))
1911    }
1912}
1913
1914/// Чтобы получить список всех тарифов серверов, отправьте GET-запрос на
1915/// `/api/v1/presets/servers`.   Тело ответа будет представлять собой объект
1916/// JSON с ключом `server_presets`.
1917pub async fn get_servers_presets(
1918    configuration: &configuration::Configuration
1919) -> Result<models::GetServersPresets200Response, Error<GetServersPresetsError>> {
1920    let uri_str = format!("{}/api/v1/presets/servers", configuration.base_path);
1921    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1922
1923    if let Some(ref user_agent) = configuration.user_agent {
1924        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1925    }
1926    if let Some(ref token) = configuration.bearer_access_token {
1927        req_builder = req_builder.bearer_auth(token.to_owned());
1928    };
1929
1930    let req = req_builder.build()?;
1931    let resp = configuration.client.execute(req).await?;
1932
1933    let status = resp.status();
1934    let content_type = resp
1935        .headers()
1936        .get("content-type")
1937        .and_then(|v| v.to_str().ok())
1938        .unwrap_or("application/octet-stream");
1939    let content_type = super::ContentType::from(content_type);
1940
1941    if !status.is_client_error() && !status.is_server_error() {
1942        let content = resp.text().await?;
1943        match content_type {
1944            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1945            ContentType::Text => {
1946                return Err(Error::from(serde_json::Error::custom(
1947                    "Received `text/plain` content type response that cannot be converted to `models::GetServersPresets200Response`"
1948                )));
1949            }
1950            ContentType::Unsupported(unknown_type) => {
1951                return Err(Error::from(serde_json::Error::custom(format!(
1952                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServersPresets200Response`"
1953                ))));
1954            }
1955        }
1956    } else {
1957        let content = resp.text().await?;
1958        let entity: Option<GetServersPresetsError> = serde_json::from_str(&content).ok();
1959        Err(Error::ResponseError(ResponseContent {
1960            status,
1961            content,
1962            entity
1963        }))
1964    }
1965}
1966
1967/// Чтобы получить список ПО из маркетплейса, отправьте GET-запрос на
1968/// `/api/v1/software/servers`.   Тело ответа будет представлять собой объект
1969/// JSON с ключом `servers_software`.
1970pub async fn get_software(
1971    configuration: &configuration::Configuration
1972) -> Result<models::GetSoftware200Response, Error<GetSoftwareError>> {
1973    let uri_str = format!("{}/api/v1/software/servers", configuration.base_path);
1974    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1975
1976    if let Some(ref user_agent) = configuration.user_agent {
1977        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1978    }
1979    if let Some(ref token) = configuration.bearer_access_token {
1980        req_builder = req_builder.bearer_auth(token.to_owned());
1981    };
1982
1983    let req = req_builder.build()?;
1984    let resp = configuration.client.execute(req).await?;
1985
1986    let status = resp.status();
1987    let content_type = resp
1988        .headers()
1989        .get("content-type")
1990        .and_then(|v| v.to_str().ok())
1991        .unwrap_or("application/octet-stream");
1992    let content_type = super::ContentType::from(content_type);
1993
1994    if !status.is_client_error() && !status.is_server_error() {
1995        let content = resp.text().await?;
1996        match content_type {
1997            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1998            ContentType::Text => {
1999                return Err(Error::from(serde_json::Error::custom(
2000                    "Received `text/plain` content type response that cannot be converted to `models::GetSoftware200Response`"
2001                )));
2002            }
2003            ContentType::Unsupported(unknown_type) => {
2004                return Err(Error::from(serde_json::Error::custom(format!(
2005                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetSoftware200Response`"
2006                ))));
2007            }
2008        }
2009    } else {
2010        let content = resp.text().await?;
2011        let entity: Option<GetSoftwareError> = serde_json::from_str(&content).ok();
2012        Err(Error::ResponseError(ResponseContent {
2013            status,
2014            content,
2015            entity
2016        }))
2017    }
2018}
2019
2020/// Чтобы выполнить принудительное выключение сервера, отправьте POST-запрос на
2021/// `/api/v1/servers/{server_id}/hard-shutdown`.
2022pub async fn hard_shutdown_server(
2023    configuration: &configuration::Configuration,
2024    server_id: i32
2025) -> Result<(), Error<HardShutdownServerError>> {
2026    // add a prefix to parameters to efficiently prevent name collisions
2027    let p_path_server_id = server_id;
2028
2029    let uri_str = format!(
2030        "{}/api/v1/servers/{server_id}/hard-shutdown",
2031        configuration.base_path,
2032        server_id = p_path_server_id
2033    );
2034    let mut req_builder = configuration
2035        .client
2036        .request(reqwest::Method::POST, &uri_str);
2037
2038    if let Some(ref user_agent) = configuration.user_agent {
2039        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2040    }
2041    if let Some(ref token) = configuration.bearer_access_token {
2042        req_builder = req_builder.bearer_auth(token.to_owned());
2043    };
2044
2045    let req = req_builder.build()?;
2046    let resp = configuration.client.execute(req).await?;
2047
2048    let status = resp.status();
2049
2050    if !status.is_client_error() && !status.is_server_error() {
2051        Ok(())
2052    } else {
2053        let content = resp.text().await?;
2054        let entity: Option<HardShutdownServerError> = serde_json::from_str(&content).ok();
2055        Err(Error::ResponseError(ResponseContent {
2056            status,
2057            content,
2058            entity
2059        }))
2060    }
2061}
2062
2063/// Чтобы отмонтировать ISO образ и перезагрузить сервер, отправьте POST-запрос
2064/// на `/api/v1/servers/{server_id}/image-unmount`.
2065pub async fn image_unmount_and_server_reload(
2066    configuration: &configuration::Configuration,
2067    server_id: i32
2068) -> Result<(), Error<ImageUnmountAndServerReloadError>> {
2069    // add a prefix to parameters to efficiently prevent name collisions
2070    let p_path_server_id = server_id;
2071
2072    let uri_str = format!(
2073        "{}/api/v1/servers/{server_id}/image-unmount",
2074        configuration.base_path,
2075        server_id = p_path_server_id
2076    );
2077    let mut req_builder = configuration
2078        .client
2079        .request(reqwest::Method::POST, &uri_str);
2080
2081    if let Some(ref user_agent) = configuration.user_agent {
2082        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2083    }
2084    if let Some(ref token) = configuration.bearer_access_token {
2085        req_builder = req_builder.bearer_auth(token.to_owned());
2086    };
2087
2088    let req = req_builder.build()?;
2089    let resp = configuration.client.execute(req).await?;
2090
2091    let status = resp.status();
2092
2093    if !status.is_client_error() && !status.is_server_error() {
2094        Ok(())
2095    } else {
2096        let content = resp.text().await?;
2097        let entity: Option<ImageUnmountAndServerReloadError> = serde_json::from_str(&content).ok();
2098        Err(Error::ResponseError(ResponseContent {
2099            status,
2100            content,
2101            entity
2102        }))
2103    }
2104}
2105
2106/// Чтобы выполнить действие над бэкапом диска сервера, отправьте POST-запрос на
2107/// `/api/v1/servers/{server_id}/disks/{disk_id}/backups/{backup_id}/action`.
2108pub async fn perform_action_on_backup(
2109    configuration: &configuration::Configuration,
2110    server_id: i32,
2111    disk_id: i32,
2112    backup_id: i32,
2113    perform_action_on_backup_request: Option<models::PerformActionOnBackupRequest>
2114) -> Result<(), Error<PerformActionOnBackupError>> {
2115    // add a prefix to parameters to efficiently prevent name collisions
2116    let p_path_server_id = server_id;
2117    let p_path_disk_id = disk_id;
2118    let p_path_backup_id = backup_id;
2119    let p_body_perform_action_on_backup_request = perform_action_on_backup_request;
2120
2121    let uri_str = format!(
2122        "{}/api/v1/servers/{server_id}/disks/{disk_id}/backups/{backup_id}/action",
2123        configuration.base_path,
2124        server_id = p_path_server_id,
2125        disk_id = p_path_disk_id,
2126        backup_id = p_path_backup_id
2127    );
2128    let mut req_builder = configuration
2129        .client
2130        .request(reqwest::Method::POST, &uri_str);
2131
2132    if let Some(ref user_agent) = configuration.user_agent {
2133        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2134    }
2135    if let Some(ref token) = configuration.bearer_access_token {
2136        req_builder = req_builder.bearer_auth(token.to_owned());
2137    };
2138    req_builder = req_builder.json(&p_body_perform_action_on_backup_request);
2139
2140    let req = req_builder.build()?;
2141    let resp = configuration.client.execute(req).await?;
2142
2143    let status = resp.status();
2144
2145    if !status.is_client_error() && !status.is_server_error() {
2146        Ok(())
2147    } else {
2148        let content = resp.text().await?;
2149        let entity: Option<PerformActionOnBackupError> = serde_json::from_str(&content).ok();
2150        Err(Error::ResponseError(ResponseContent {
2151            status,
2152            content,
2153            entity
2154        }))
2155    }
2156}
2157
2158/// Чтобы выполнить действие над сервером, отправьте POST-запрос на
2159/// `/api/v1/servers/{server_id}/action`.
2160#[deprecated]
2161pub async fn perform_action_on_server(
2162    configuration: &configuration::Configuration,
2163    server_id: i32,
2164    perform_action_on_server_request: Option<models::PerformActionOnServerRequest>
2165) -> Result<(), Error<PerformActionOnServerError>> {
2166    // add a prefix to parameters to efficiently prevent name collisions
2167    let p_path_server_id = server_id;
2168    let p_body_perform_action_on_server_request = perform_action_on_server_request;
2169
2170    let uri_str = format!(
2171        "{}/api/v1/servers/{server_id}/action",
2172        configuration.base_path,
2173        server_id = p_path_server_id
2174    );
2175    let mut req_builder = configuration
2176        .client
2177        .request(reqwest::Method::POST, &uri_str);
2178
2179    if let Some(ref user_agent) = configuration.user_agent {
2180        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2181    }
2182    if let Some(ref token) = configuration.bearer_access_token {
2183        req_builder = req_builder.bearer_auth(token.to_owned());
2184    };
2185    req_builder = req_builder.json(&p_body_perform_action_on_server_request);
2186
2187    let req = req_builder.build()?;
2188    let resp = configuration.client.execute(req).await?;
2189
2190    let status = resp.status();
2191
2192    if !status.is_client_error() && !status.is_server_error() {
2193        Ok(())
2194    } else {
2195        let content = resp.text().await?;
2196        let entity: Option<PerformActionOnServerError> = serde_json::from_str(&content).ok();
2197        Err(Error::ResponseError(ResponseContent {
2198            status,
2199            content,
2200            entity
2201        }))
2202    }
2203}
2204
2205/// Чтобы перезагрузить сервер, отправьте POST-запрос на
2206/// `/api/v1/servers/{server_id}/reboot`.
2207pub async fn reboot_server(
2208    configuration: &configuration::Configuration,
2209    server_id: i32
2210) -> Result<(), Error<RebootServerError>> {
2211    // add a prefix to parameters to efficiently prevent name collisions
2212    let p_path_server_id = server_id;
2213
2214    let uri_str = format!(
2215        "{}/api/v1/servers/{server_id}/reboot",
2216        configuration.base_path,
2217        server_id = p_path_server_id
2218    );
2219    let mut req_builder = configuration
2220        .client
2221        .request(reqwest::Method::POST, &uri_str);
2222
2223    if let Some(ref user_agent) = configuration.user_agent {
2224        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2225    }
2226    if let Some(ref token) = configuration.bearer_access_token {
2227        req_builder = req_builder.bearer_auth(token.to_owned());
2228    };
2229
2230    let req = req_builder.build()?;
2231    let resp = configuration.client.execute(req).await?;
2232
2233    let status = resp.status();
2234
2235    if !status.is_client_error() && !status.is_server_error() {
2236        Ok(())
2237    } else {
2238        let content = resp.text().await?;
2239        let entity: Option<RebootServerError> = serde_json::from_str(&content).ok();
2240        Err(Error::ResponseError(ResponseContent {
2241            status,
2242            content,
2243            entity
2244        }))
2245    }
2246}
2247
2248/// Чтобы принудительно перезагрузить сервер, отправьте POST-запрос на
2249/// `/api/v1/servers/{server_id}/hard-reboot`.
2250pub async fn reboot_server_hard(
2251    configuration: &configuration::Configuration,
2252    server_id: i32
2253) -> Result<(), Error<RebootServerHardError>> {
2254    // add a prefix to parameters to efficiently prevent name collisions
2255    let p_path_server_id = server_id;
2256
2257    let uri_str = format!(
2258        "{}/api/v1/servers/{server_id}/hard-reboot",
2259        configuration.base_path,
2260        server_id = p_path_server_id
2261    );
2262    let mut req_builder = configuration
2263        .client
2264        .request(reqwest::Method::POST, &uri_str);
2265
2266    if let Some(ref user_agent) = configuration.user_agent {
2267        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2268    }
2269    if let Some(ref token) = configuration.bearer_access_token {
2270        req_builder = req_builder.bearer_auth(token.to_owned());
2271    };
2272
2273    let req = req_builder.build()?;
2274    let resp = configuration.client.execute(req).await?;
2275
2276    let status = resp.status();
2277
2278    if !status.is_client_error() && !status.is_server_error() {
2279        Ok(())
2280    } else {
2281        let content = resp.text().await?;
2282        let entity: Option<RebootServerHardError> = serde_json::from_str(&content).ok();
2283        Err(Error::ResponseError(ResponseContent {
2284            status,
2285            content,
2286            entity
2287        }))
2288    }
2289}
2290
2291/// Чтобы сбросить пароль сервера, отправьте POST-запрос на
2292/// `/api/v1/servers/{server_id}/reset-password`.
2293pub async fn reset_server_password(
2294    configuration: &configuration::Configuration,
2295    server_id: i32
2296) -> Result<(), Error<ResetServerPasswordError>> {
2297    // add a prefix to parameters to efficiently prevent name collisions
2298    let p_path_server_id = server_id;
2299
2300    let uri_str = format!(
2301        "{}/api/v1/servers/{server_id}/reset-password",
2302        configuration.base_path,
2303        server_id = p_path_server_id
2304    );
2305    let mut req_builder = configuration
2306        .client
2307        .request(reqwest::Method::POST, &uri_str);
2308
2309    if let Some(ref user_agent) = configuration.user_agent {
2310        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2311    }
2312    if let Some(ref token) = configuration.bearer_access_token {
2313        req_builder = req_builder.bearer_auth(token.to_owned());
2314    };
2315
2316    let req = req_builder.build()?;
2317    let resp = configuration.client.execute(req).await?;
2318
2319    let status = resp.status();
2320
2321    if !status.is_client_error() && !status.is_server_error() {
2322        Ok(())
2323    } else {
2324        let content = resp.text().await?;
2325        let entity: Option<ResetServerPasswordError> = serde_json::from_str(&content).ok();
2326        Err(Error::ResponseError(ResponseContent {
2327            status,
2328            content,
2329            entity
2330        }))
2331    }
2332}
2333
2334/// Чтобы выключить сервер, отправьте POST-запрос на
2335/// `/api/v1/servers/{server_id}/shutdown`.
2336pub async fn shutdown_server(
2337    configuration: &configuration::Configuration,
2338    server_id: i32
2339) -> Result<(), Error<ShutdownServerError>> {
2340    // add a prefix to parameters to efficiently prevent name collisions
2341    let p_path_server_id = server_id;
2342
2343    let uri_str = format!(
2344        "{}/api/v1/servers/{server_id}/shutdown",
2345        configuration.base_path,
2346        server_id = p_path_server_id
2347    );
2348    let mut req_builder = configuration
2349        .client
2350        .request(reqwest::Method::POST, &uri_str);
2351
2352    if let Some(ref user_agent) = configuration.user_agent {
2353        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2354    }
2355    if let Some(ref token) = configuration.bearer_access_token {
2356        req_builder = req_builder.bearer_auth(token.to_owned());
2357    };
2358
2359    let req = req_builder.build()?;
2360    let resp = configuration.client.execute(req).await?;
2361
2362    let status = resp.status();
2363
2364    if !status.is_client_error() && !status.is_server_error() {
2365        Ok(())
2366    } else {
2367        let content = resp.text().await?;
2368        let entity: Option<ShutdownServerError> = serde_json::from_str(&content).ok();
2369        Err(Error::ResponseError(ResponseContent {
2370            status,
2371            content,
2372            entity
2373        }))
2374    }
2375}
2376
2377/// Чтобы запустить сервер, отправьте POST-запрос на
2378/// `/api/v1/servers/{server_id}/start`.
2379pub async fn start_server(
2380    configuration: &configuration::Configuration,
2381    server_id: i32
2382) -> Result<(), Error<StartServerError>> {
2383    // add a prefix to parameters to efficiently prevent name collisions
2384    let p_path_server_id = server_id;
2385
2386    let uri_str = format!(
2387        "{}/api/v1/servers/{server_id}/start",
2388        configuration.base_path,
2389        server_id = p_path_server_id
2390    );
2391    let mut req_builder = configuration
2392        .client
2393        .request(reqwest::Method::POST, &uri_str);
2394
2395    if let Some(ref user_agent) = configuration.user_agent {
2396        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2397    }
2398    if let Some(ref token) = configuration.bearer_access_token {
2399        req_builder = req_builder.bearer_auth(token.to_owned());
2400    };
2401
2402    let req = req_builder.build()?;
2403    let resp = configuration.client.execute(req).await?;
2404
2405    let status = resp.status();
2406
2407    if !status.is_client_error() && !status.is_server_error() {
2408        Ok(())
2409    } else {
2410        let content = resp.text().await?;
2411        let entity: Option<StartServerError> = serde_json::from_str(&content).ok();
2412        Err(Error::ResponseError(ResponseContent {
2413            status,
2414            content,
2415            entity
2416        }))
2417    }
2418}
2419
2420/// Чтобы обновить только определенные атрибуты сервера, отправьте запрос PATCH
2421/// в `/api/v1/servers/{server_id}`.
2422pub async fn update_server(
2423    configuration: &configuration::Configuration,
2424    server_id: i32,
2425    update_server: models::UpdateServer
2426) -> Result<models::CreateServer201Response, Error<UpdateServerError>> {
2427    // add a prefix to parameters to efficiently prevent name collisions
2428    let p_path_server_id = server_id;
2429    let p_body_update_server = update_server;
2430
2431    let uri_str = format!(
2432        "{}/api/v1/servers/{server_id}",
2433        configuration.base_path,
2434        server_id = p_path_server_id
2435    );
2436    let mut req_builder = configuration
2437        .client
2438        .request(reqwest::Method::PATCH, &uri_str);
2439
2440    if let Some(ref user_agent) = configuration.user_agent {
2441        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2442    }
2443    if let Some(ref token) = configuration.bearer_access_token {
2444        req_builder = req_builder.bearer_auth(token.to_owned());
2445    };
2446    req_builder = req_builder.json(&p_body_update_server);
2447
2448    let req = req_builder.build()?;
2449    let resp = configuration.client.execute(req).await?;
2450
2451    let status = resp.status();
2452    let content_type = resp
2453        .headers()
2454        .get("content-type")
2455        .and_then(|v| v.to_str().ok())
2456        .unwrap_or("application/octet-stream");
2457    let content_type = super::ContentType::from(content_type);
2458
2459    if !status.is_client_error() && !status.is_server_error() {
2460        let content = resp.text().await?;
2461        match content_type {
2462            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2463            ContentType::Text => {
2464                return Err(Error::from(serde_json::Error::custom(
2465                    "Received `text/plain` content type response that cannot be converted to `models::CreateServer201Response`"
2466                )));
2467            }
2468            ContentType::Unsupported(unknown_type) => {
2469                return Err(Error::from(serde_json::Error::custom(format!(
2470                    "Received `{unknown_type}` content type response that cannot be converted to `models::CreateServer201Response`"
2471                ))));
2472            }
2473        }
2474    } else {
2475        let content = resp.text().await?;
2476        let entity: Option<UpdateServerError> = serde_json::from_str(&content).ok();
2477        Err(Error::ResponseError(ResponseContent {
2478            status,
2479            content,
2480            entity
2481        }))
2482    }
2483}
2484
2485/// Чтобы изменить параметры диска сервера, отправьте PATCH-запрос на
2486/// `/api/v1/servers/{server_id}/disks/{disk_id}`.
2487pub async fn update_server_disk(
2488    configuration: &configuration::Configuration,
2489    server_id: i32,
2490    disk_id: i32,
2491    update_server_disk_request: Option<models::UpdateServerDiskRequest>
2492) -> Result<models::CreateServerDisk201Response, Error<UpdateServerDiskError>> {
2493    // add a prefix to parameters to efficiently prevent name collisions
2494    let p_path_server_id = server_id;
2495    let p_path_disk_id = disk_id;
2496    let p_body_update_server_disk_request = update_server_disk_request;
2497
2498    let uri_str = format!(
2499        "{}/api/v1/servers/{server_id}/disks/{disk_id}",
2500        configuration.base_path,
2501        server_id = p_path_server_id,
2502        disk_id = p_path_disk_id
2503    );
2504    let mut req_builder = configuration
2505        .client
2506        .request(reqwest::Method::PATCH, &uri_str);
2507
2508    if let Some(ref user_agent) = configuration.user_agent {
2509        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2510    }
2511    if let Some(ref token) = configuration.bearer_access_token {
2512        req_builder = req_builder.bearer_auth(token.to_owned());
2513    };
2514    req_builder = req_builder.json(&p_body_update_server_disk_request);
2515
2516    let req = req_builder.build()?;
2517    let resp = configuration.client.execute(req).await?;
2518
2519    let status = resp.status();
2520    let content_type = resp
2521        .headers()
2522        .get("content-type")
2523        .and_then(|v| v.to_str().ok())
2524        .unwrap_or("application/octet-stream");
2525    let content_type = super::ContentType::from(content_type);
2526
2527    if !status.is_client_error() && !status.is_server_error() {
2528        let content = resp.text().await?;
2529        match content_type {
2530            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2531            ContentType::Text => {
2532                return Err(Error::from(serde_json::Error::custom(
2533                    "Received `text/plain` content type response that cannot be converted to `models::CreateServerDisk201Response`"
2534                )));
2535            }
2536            ContentType::Unsupported(unknown_type) => {
2537                return Err(Error::from(serde_json::Error::custom(format!(
2538                    "Received `{unknown_type}` content type response that cannot be converted to `models::CreateServerDisk201Response`"
2539                ))));
2540            }
2541        }
2542    } else {
2543        let content = resp.text().await?;
2544        let entity: Option<UpdateServerDiskError> = serde_json::from_str(&content).ok();
2545        Err(Error::ResponseError(ResponseContent {
2546            status,
2547            content,
2548            entity
2549        }))
2550    }
2551}
2552
2553/// Чтобы изменить настройки автобэкапов диска сервера, отправьте PATCH-запрос
2554/// на `/api/v1/servers/{server_id}/disks/{disk_id}/auto-backups`.
2555pub async fn update_server_disk_auto_backup_settings(
2556    configuration: &configuration::Configuration,
2557    server_id: i32,
2558    disk_id: i32,
2559    auto_backup: Option<models::AutoBackup>
2560) -> Result<
2561    models::GetServerDiskAutoBackupSettings200Response,
2562    Error<UpdateServerDiskAutoBackupSettingsError>
2563> {
2564    // add a prefix to parameters to efficiently prevent name collisions
2565    let p_path_server_id = server_id;
2566    let p_path_disk_id = disk_id;
2567    let p_body_auto_backup = auto_backup;
2568
2569    let uri_str = format!(
2570        "{}/api/v1/servers/{server_id}/disks/{disk_id}/auto-backups",
2571        configuration.base_path,
2572        server_id = p_path_server_id,
2573        disk_id = p_path_disk_id
2574    );
2575    let mut req_builder = configuration
2576        .client
2577        .request(reqwest::Method::PATCH, &uri_str);
2578
2579    if let Some(ref user_agent) = configuration.user_agent {
2580        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2581    }
2582    if let Some(ref token) = configuration.bearer_access_token {
2583        req_builder = req_builder.bearer_auth(token.to_owned());
2584    };
2585    req_builder = req_builder.json(&p_body_auto_backup);
2586
2587    let req = req_builder.build()?;
2588    let resp = configuration.client.execute(req).await?;
2589
2590    let status = resp.status();
2591    let content_type = resp
2592        .headers()
2593        .get("content-type")
2594        .and_then(|v| v.to_str().ok())
2595        .unwrap_or("application/octet-stream");
2596    let content_type = super::ContentType::from(content_type);
2597
2598    if !status.is_client_error() && !status.is_server_error() {
2599        let content = resp.text().await?;
2600        match content_type {
2601            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2602            ContentType::Text => {
2603                return Err(Error::from(serde_json::Error::custom(
2604                    "Received `text/plain` content type response that cannot be converted to `models::GetServerDiskAutoBackupSettings200Response`"
2605                )));
2606            }
2607            ContentType::Unsupported(unknown_type) => {
2608                return Err(Error::from(serde_json::Error::custom(format!(
2609                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServerDiskAutoBackupSettings200Response`"
2610                ))));
2611            }
2612        }
2613    } else {
2614        let content = resp.text().await?;
2615        let entity: Option<UpdateServerDiskAutoBackupSettingsError> =
2616            serde_json::from_str(&content).ok();
2617        Err(Error::ResponseError(ResponseContent {
2618            status,
2619            content,
2620            entity
2621        }))
2622    }
2623}
2624
2625/// Чтобы изменить бэкап диска сервера, отправьте PATCH-запрос на
2626/// `/api/v1/servers/{server_id}/disks/{disk_id}/backups/{backup_id}`.
2627pub async fn update_server_disk_backup(
2628    configuration: &configuration::Configuration,
2629    server_id: i32,
2630    disk_id: i32,
2631    backup_id: i32,
2632    update_server_disk_backup_request: Option<models::UpdateServerDiskBackupRequest>
2633) -> Result<models::GetServerDiskBackup200Response, Error<UpdateServerDiskBackupError>> {
2634    // add a prefix to parameters to efficiently prevent name collisions
2635    let p_path_server_id = server_id;
2636    let p_path_disk_id = disk_id;
2637    let p_path_backup_id = backup_id;
2638    let p_body_update_server_disk_backup_request = update_server_disk_backup_request;
2639
2640    let uri_str = format!(
2641        "{}/api/v1/servers/{server_id}/disks/{disk_id}/backups/{backup_id}",
2642        configuration.base_path,
2643        server_id = p_path_server_id,
2644        disk_id = p_path_disk_id,
2645        backup_id = p_path_backup_id
2646    );
2647    let mut req_builder = configuration
2648        .client
2649        .request(reqwest::Method::PATCH, &uri_str);
2650
2651    if let Some(ref user_agent) = configuration.user_agent {
2652        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2653    }
2654    if let Some(ref token) = configuration.bearer_access_token {
2655        req_builder = req_builder.bearer_auth(token.to_owned());
2656    };
2657    req_builder = req_builder.json(&p_body_update_server_disk_backup_request);
2658
2659    let req = req_builder.build()?;
2660    let resp = configuration.client.execute(req).await?;
2661
2662    let status = resp.status();
2663    let content_type = resp
2664        .headers()
2665        .get("content-type")
2666        .and_then(|v| v.to_str().ok())
2667        .unwrap_or("application/octet-stream");
2668    let content_type = super::ContentType::from(content_type);
2669
2670    if !status.is_client_error() && !status.is_server_error() {
2671        let content = resp.text().await?;
2672        match content_type {
2673            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2674            ContentType::Text => {
2675                return Err(Error::from(serde_json::Error::custom(
2676                    "Received `text/plain` content type response that cannot be converted to `models::GetServerDiskBackup200Response`"
2677                )));
2678            }
2679            ContentType::Unsupported(unknown_type) => {
2680                return Err(Error::from(serde_json::Error::custom(format!(
2681                    "Received `{unknown_type}` content type response that cannot be converted to `models::GetServerDiskBackup200Response`"
2682                ))));
2683            }
2684        }
2685    } else {
2686        let content = resp.text().await?;
2687        let entity: Option<UpdateServerDiskBackupError> = serde_json::from_str(&content).ok();
2688        Err(Error::ResponseError(ResponseContent {
2689            status,
2690            content,
2691            entity
2692        }))
2693    }
2694}
2695
2696/// Чтобы изменить IP-адрес сервера, отправьте POST-запрос на
2697/// `/api/v1/servers/{server_id}/ips`.
2698pub async fn update_server_ip(
2699    configuration: &configuration::Configuration,
2700    server_id: i32,
2701    update_server_ip_request: models::UpdateServerIpRequest
2702) -> Result<models::AddServerIp201Response, Error<UpdateServerIpError>> {
2703    // add a prefix to parameters to efficiently prevent name collisions
2704    let p_path_server_id = server_id;
2705    let p_body_update_server_ip_request = update_server_ip_request;
2706
2707    let uri_str = format!(
2708        "{}/api/v1/servers/{server_id}/ips",
2709        configuration.base_path,
2710        server_id = p_path_server_id
2711    );
2712    let mut req_builder = configuration
2713        .client
2714        .request(reqwest::Method::PATCH, &uri_str);
2715
2716    if let Some(ref user_agent) = configuration.user_agent {
2717        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2718    }
2719    if let Some(ref token) = configuration.bearer_access_token {
2720        req_builder = req_builder.bearer_auth(token.to_owned());
2721    };
2722    req_builder = req_builder.json(&p_body_update_server_ip_request);
2723
2724    let req = req_builder.build()?;
2725    let resp = configuration.client.execute(req).await?;
2726
2727    let status = resp.status();
2728    let content_type = resp
2729        .headers()
2730        .get("content-type")
2731        .and_then(|v| v.to_str().ok())
2732        .unwrap_or("application/octet-stream");
2733    let content_type = super::ContentType::from(content_type);
2734
2735    if !status.is_client_error() && !status.is_server_error() {
2736        let content = resp.text().await?;
2737        match content_type {
2738            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2739            ContentType::Text => {
2740                return Err(Error::from(serde_json::Error::custom(
2741                    "Received `text/plain` content type response that cannot be converted to `models::AddServerIp201Response`"
2742                )));
2743            }
2744            ContentType::Unsupported(unknown_type) => {
2745                return Err(Error::from(serde_json::Error::custom(format!(
2746                    "Received `{unknown_type}` content type response that cannot be converted to `models::AddServerIp201Response`"
2747                ))));
2748            }
2749        }
2750    } else {
2751        let content = resp.text().await?;
2752        let entity: Option<UpdateServerIpError> = serde_json::from_str(&content).ok();
2753        Err(Error::ResponseError(ResponseContent {
2754            status,
2755            content,
2756            entity
2757        }))
2758    }
2759}
2760
2761/// Чтобы измененить правила маршрутизации трафика сервера (NAT), отправьте
2762/// PATCH-запрос на `/api/v1/servers/{server_id}/local-networks/nat-mode`.
2763pub async fn update_server_nat(
2764    configuration: &configuration::Configuration,
2765    server_id: i32,
2766    update_server_nat_request: Option<models::UpdateServerNatRequest>
2767) -> Result<(), Error<UpdateServerNatError>> {
2768    // add a prefix to parameters to efficiently prevent name collisions
2769    let p_path_server_id = server_id;
2770    let p_body_update_server_nat_request = update_server_nat_request;
2771
2772    let uri_str = format!(
2773        "{}/api/v1/servers/{server_id}/local-networks/nat-mode",
2774        configuration.base_path,
2775        server_id = p_path_server_id
2776    );
2777    let mut req_builder = configuration
2778        .client
2779        .request(reqwest::Method::PATCH, &uri_str);
2780
2781    if let Some(ref user_agent) = configuration.user_agent {
2782        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2783    }
2784    if let Some(ref token) = configuration.bearer_access_token {
2785        req_builder = req_builder.bearer_auth(token.to_owned());
2786    };
2787    req_builder = req_builder.json(&p_body_update_server_nat_request);
2788
2789    let req = req_builder.build()?;
2790    let resp = configuration.client.execute(req).await?;
2791
2792    let status = resp.status();
2793
2794    if !status.is_client_error() && !status.is_server_error() {
2795        Ok(())
2796    } else {
2797        let content = resp.text().await?;
2798        let entity: Option<UpdateServerNatError> = serde_json::from_str(&content).ok();
2799        Err(Error::ResponseError(ResponseContent {
2800            status,
2801            content,
2802            entity
2803        }))
2804    }
2805}
2806
2807/// Чтобы изменить тип загрузки операционной системы сервера, отправьте
2808/// POST-запрос на `/api/v1/servers/{server_id}/boot-mode`. \\  После смены типа
2809/// загрузки сервер будет перезапущен.
2810pub async fn update_server_os_boot_mode(
2811    configuration: &configuration::Configuration,
2812    server_id: i32,
2813    update_server_os_boot_mode_request: Option<models::UpdateServerOsBootModeRequest>
2814) -> Result<(), Error<UpdateServerOsBootModeError>> {
2815    // add a prefix to parameters to efficiently prevent name collisions
2816    let p_path_server_id = server_id;
2817    let p_body_update_server_os_boot_mode_request = update_server_os_boot_mode_request;
2818
2819    let uri_str = format!(
2820        "{}/api/v1/servers/{server_id}/boot-mode",
2821        configuration.base_path,
2822        server_id = p_path_server_id
2823    );
2824    let mut req_builder = configuration
2825        .client
2826        .request(reqwest::Method::POST, &uri_str);
2827
2828    if let Some(ref user_agent) = configuration.user_agent {
2829        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2830    }
2831    if let Some(ref token) = configuration.bearer_access_token {
2832        req_builder = req_builder.bearer_auth(token.to_owned());
2833    };
2834    req_builder = req_builder.json(&p_body_update_server_os_boot_mode_request);
2835
2836    let req = req_builder.build()?;
2837    let resp = configuration.client.execute(req).await?;
2838
2839    let status = resp.status();
2840
2841    if !status.is_client_error() && !status.is_server_error() {
2842        Ok(())
2843    } else {
2844        let content = resp.text().await?;
2845        let entity: Option<UpdateServerOsBootModeError> = serde_json::from_str(&content).ok();
2846        Err(Error::ResponseError(ResponseContent {
2847            status,
2848            content,
2849            entity
2850        }))
2851    }
2852}
timeweb_rs/apis/servers_api.rs

timeweb_rs/apis/
servers_api.rs
