#![cfg(feature = "hetzner_servers")]
#![allow(clippy::too_many_arguments, clippy::type_complexity)]
#![allow(clippy::missing_errors_doc, clippy::doc_markdown, clippy::useless_format)]
#![allow(unused_imports)]
use foundation_netio::{DynNetClient, PreparedRequestBuilder};
use foundation_netio::shared::client::http_client::HttpClient;
use serde::{Deserialize, Serialize};
use foundation_macros::JsonHash;
use super::shared::ApiResponse;
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerRequest {
pub automount: Option<bool>,
pub firewalls: Option<Vec<CreateServerRequestFirewallsItem>>,
pub image: String,
pub labels: Option<serde_json::Value>,
pub location: Option<String>,
pub name: String,
pub networks: Option<Vec<i64>>,
pub placement_group: Option<i64>,
pub public_net: Option<CreateServerRequestPublicNet>,
pub server_type: String,
pub ssh_keys: Option<Vec<String>>,
pub start_after_create: Option<bool>,
pub user_data: Option<String>,
pub volumes: Option<Vec<i64>>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerRequestFirewallsItem {
pub firewall: i64,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerRequestPublicNet {
pub enable_ipv4: Option<bool>,
pub enable_ipv6: Option<bool>,
pub ipv4: Option<i64>,
pub ipv6: Option<i64>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponse {
pub action: CreateServerResponseAction,
pub next_actions: Vec<CreateServerResponseNextActionsItem>,
pub root_password: Option<String>,
pub server: CreateServerResponseServer,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseAction {
pub command: String,
pub error: Option<CreateServerResponseActionError>,
pub finished: Option<String>,
pub id: i64,
pub progress: i64,
pub resources: Vec<CreateServerResponseActionResourcesItem>,
pub started: String,
pub status: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseActionError {
pub code: String,
pub message: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseActionResourcesItem {
pub id: i64,
#[serde(rename = "type")]
pub r#type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseNextActionsItem {
pub command: String,
pub error: Option<CreateServerResponseNextActionsItemError>,
pub finished: Option<String>,
pub id: i64,
pub progress: i64,
pub resources: Vec<CreateServerResponseNextActionsItemResourcesItem>,
pub started: String,
pub status: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseNextActionsItemError {
pub code: String,
pub message: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseNextActionsItemResourcesItem {
pub id: i64,
#[serde(rename = "type")]
pub r#type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServer {
pub backup_window: Option<String>,
pub created: String,
pub id: i64,
pub image: Option<CreateServerResponseServerImage>,
pub included_traffic: Option<i64>,
pub ingoing_traffic: Option<i64>,
pub iso: Option<CreateServerResponseServerIso>,
pub labels: serde_json::Value,
pub load_balancers: Option<Vec<i64>>,
pub location: CreateServerResponseServerLocation,
pub locked: bool,
pub name: String,
pub outgoing_traffic: Option<i64>,
pub placement_group: Option<CreateServerResponseServerPlacementGroup>,
pub primary_disk_size: f64,
pub private_net: Vec<CreateServerResponseServerPrivateNetItem>,
pub protection: CreateServerResponseServerProtection,
pub public_net: CreateServerResponseServerPublicNet,
pub rescue_enabled: bool,
pub server_type: CreateServerResponseServerServerType,
pub status: String,
pub volumes: Option<Vec<i64>>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerImage {
pub architecture: String,
pub bound_to: Option<i64>,
pub created: String,
pub created_from: Option<CreateServerResponseServerImageCreatedFrom>,
pub deleted: Option<String>,
pub deprecated: Option<String>,
pub description: String,
pub disk_size: f64,
pub id: i64,
pub image_size: Option<f64>,
pub labels: serde_json::Value,
pub name: Option<String>,
pub os_flavor: String,
pub os_version: Option<String>,
pub protection: CreateServerResponseServerImageProtection,
pub rapid_deploy: Option<bool>,
pub status: String,
#[serde(rename = "type")]
pub r#type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerImageCreatedFrom {
pub id: i64,
pub name: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerImageProtection {
pub delete: bool,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerIso {
pub architecture: Option<String>,
pub deprecation: Option<CreateServerResponseServerIsoDeprecation>,
pub description: String,
pub id: i64,
pub name: Option<String>,
#[serde(rename = "type")]
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerIsoDeprecation {
pub announced: String,
pub unavailable_after: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerLocation {
pub city: String,
pub country: String,
pub description: String,
pub id: i64,
pub latitude: f64,
pub longitude: f64,
pub name: String,
pub network_zone: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerPlacementGroup {
pub created: String,
pub id: i64,
pub labels: serde_json::Value,
pub name: String,
pub servers: Vec<i64>,
#[serde(rename = "type")]
pub r#type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerPrivateNetItem {
pub alias_ips: Option<Vec<String>>,
pub ip: Option<String>,
pub mac_address: Option<String>,
pub network: Option<i64>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerProtection {
pub delete: bool,
pub rebuild: bool,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerPublicNet {
pub firewalls: Option<Vec<CreateServerResponseServerPublicNetFirewallsItem>>,
pub floating_ips: Vec<i64>,
pub ipv4: Option<CreateServerResponseServerPublicNetIpv4>,
pub ipv6: Option<CreateServerResponseServerPublicNetIpv6>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerPublicNetFirewallsItem {
pub id: Option<i64>,
pub status: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerPublicNetIpv4 {
pub blocked: bool,
pub dns_ptr: String,
pub id: Option<i64>,
pub ip: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerPublicNetIpv6 {
pub blocked: bool,
pub dns_ptr: Option<Vec<CreateServerResponseServerPublicNetIpv6DnsPtrItem>>,
pub id: Option<i64>,
pub ip: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerPublicNetIpv6DnsPtrItem {
pub dns_ptr: String,
pub ip: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerServerType {
pub architecture: String,
pub category: Option<String>,
pub cores: f64,
pub cpu_type: String,
pub deprecated: bool,
pub deprecation: Option<CreateServerResponseServerServerTypeDeprecation>,
pub description: String,
pub disk: f64,
pub id: i64,
pub locations: Vec<CreateServerResponseServerServerTypeLocationsItem>,
pub memory: f64,
pub name: String,
pub prices: Vec<CreateServerResponseServerServerTypePricesItem>,
pub storage_type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerServerTypeDeprecation {
pub announced: String,
pub unavailable_after: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerServerTypeLocationsItem {
pub available: bool,
pub deprecation: Option<CreateServerResponseServerServerTypeLocationsItemDeprecation>,
pub id: i64,
pub name: String,
pub recommended: bool,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerServerTypeLocationsItemDeprecation {
pub announced: String,
pub unavailable_after: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerServerTypePricesItem {
pub included_traffic: i64,
pub location: String,
pub price_hourly: CreateServerResponseServerServerTypePricesItemPriceHourly,
pub price_monthly: CreateServerResponseServerServerTypePricesItemPriceMonthly,
pub price_per_tb_traffic: CreateServerResponseServerServerTypePricesItemPricePerTbTraffic,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerServerTypePricesItemPriceHourly {
pub gross: String,
pub net: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerServerTypePricesItemPriceMonthly {
pub gross: String,
pub net: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct CreateServerResponseServerServerTypePricesItemPricePerTbTraffic {
pub gross: String,
pub net: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DeleteServerResponse {
pub action: Option<DeleteServerResponseAction>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DeleteServerResponseAction {
pub command: String,
pub error: Option<DeleteServerResponseActionError>,
pub finished: Option<String>,
pub id: i64,
pub progress: i64,
pub resources: Vec<DeleteServerResponseActionResourcesItem>,
pub started: String,
pub status: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DeleteServerResponseActionError {
pub code: String,
pub message: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct DeleteServerResponseActionResourcesItem {
pub id: i64,
#[serde(rename = "type")]
pub r#type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponse {
pub server: Option<GetServerResponseServer>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServer {
pub backup_window: Option<String>,
pub created: String,
pub id: i64,
pub image: Option<GetServerResponseServerImage>,
pub included_traffic: Option<i64>,
pub ingoing_traffic: Option<i64>,
pub iso: Option<GetServerResponseServerIso>,
pub labels: serde_json::Value,
pub load_balancers: Option<Vec<i64>>,
pub location: GetServerResponseServerLocation,
pub locked: bool,
pub name: String,
pub outgoing_traffic: Option<i64>,
pub placement_group: Option<GetServerResponseServerPlacementGroup>,
pub primary_disk_size: f64,
pub private_net: Vec<GetServerResponseServerPrivateNetItem>,
pub protection: GetServerResponseServerProtection,
pub public_net: GetServerResponseServerPublicNet,
pub rescue_enabled: bool,
pub server_type: GetServerResponseServerServerType,
pub status: String,
pub volumes: Option<Vec<i64>>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerImage {
pub architecture: String,
pub bound_to: Option<i64>,
pub created: String,
pub created_from: Option<GetServerResponseServerImageCreatedFrom>,
pub deleted: Option<String>,
pub deprecated: Option<String>,
pub description: String,
pub disk_size: f64,
pub id: i64,
pub image_size: Option<f64>,
pub labels: serde_json::Value,
pub name: Option<String>,
pub os_flavor: String,
pub os_version: Option<String>,
pub protection: GetServerResponseServerImageProtection,
pub rapid_deploy: Option<bool>,
pub status: String,
#[serde(rename = "type")]
pub r#type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerImageCreatedFrom {
pub id: i64,
pub name: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerImageProtection {
pub delete: bool,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerIso {
pub architecture: Option<String>,
pub deprecation: Option<GetServerResponseServerIsoDeprecation>,
pub description: String,
pub id: i64,
pub name: Option<String>,
#[serde(rename = "type")]
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerIsoDeprecation {
pub announced: String,
pub unavailable_after: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerLocation {
pub city: String,
pub country: String,
pub description: String,
pub id: i64,
pub latitude: f64,
pub longitude: f64,
pub name: String,
pub network_zone: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerPlacementGroup {
pub created: String,
pub id: i64,
pub labels: serde_json::Value,
pub name: String,
pub servers: Vec<i64>,
#[serde(rename = "type")]
pub r#type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerPrivateNetItem {
pub alias_ips: Option<Vec<String>>,
pub ip: Option<String>,
pub mac_address: Option<String>,
pub network: Option<i64>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerProtection {
pub delete: bool,
pub rebuild: bool,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerPublicNet {
pub firewalls: Option<Vec<GetServerResponseServerPublicNetFirewallsItem>>,
pub floating_ips: Vec<i64>,
pub ipv4: Option<GetServerResponseServerPublicNetIpv4>,
pub ipv6: Option<GetServerResponseServerPublicNetIpv6>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerPublicNetFirewallsItem {
pub id: Option<i64>,
pub status: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerPublicNetIpv4 {
pub blocked: bool,
pub dns_ptr: String,
pub id: Option<i64>,
pub ip: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerPublicNetIpv6 {
pub blocked: bool,
pub dns_ptr: Option<Vec<GetServerResponseServerPublicNetIpv6DnsPtrItem>>,
pub id: Option<i64>,
pub ip: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerPublicNetIpv6DnsPtrItem {
pub dns_ptr: String,
pub ip: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerServerType {
pub architecture: String,
pub category: Option<String>,
pub cores: f64,
pub cpu_type: String,
pub deprecated: bool,
pub deprecation: Option<GetServerResponseServerServerTypeDeprecation>,
pub description: String,
pub disk: f64,
pub id: i64,
pub locations: Vec<GetServerResponseServerServerTypeLocationsItem>,
pub memory: f64,
pub name: String,
pub prices: Vec<GetServerResponseServerServerTypePricesItem>,
pub storage_type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerServerTypeDeprecation {
pub announced: String,
pub unavailable_after: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerServerTypeLocationsItem {
pub available: bool,
pub deprecation: Option<GetServerResponseServerServerTypeLocationsItemDeprecation>,
pub id: i64,
pub name: String,
pub recommended: bool,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerServerTypeLocationsItemDeprecation {
pub announced: String,
pub unavailable_after: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerServerTypePricesItem {
pub included_traffic: i64,
pub location: String,
pub price_hourly: GetServerResponseServerServerTypePricesItemPriceHourly,
pub price_monthly: GetServerResponseServerServerTypePricesItemPriceMonthly,
pub price_per_tb_traffic: GetServerResponseServerServerTypePricesItemPricePerTbTraffic,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerServerTypePricesItemPriceHourly {
pub gross: String,
pub net: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerServerTypePricesItemPriceMonthly {
pub gross: String,
pub net: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct GetServerResponseServerServerTypePricesItemPricePerTbTraffic {
pub gross: String,
pub net: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponse {
pub meta: ListServersResponseMeta,
pub servers: Vec<ListServersResponseServersItem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseMeta {
pub pagination: ListServersResponseMetaPagination,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseMetaPagination {
pub last_page: Option<i64>,
pub next_page: Option<i64>,
pub page: i64,
pub per_page: i64,
pub previous_page: Option<i64>,
pub total_entries: Option<i64>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItem {
pub backup_window: Option<String>,
pub created: String,
pub id: i64,
pub image: Option<ListServersResponseServersItemImage>,
pub included_traffic: Option<i64>,
pub ingoing_traffic: Option<i64>,
pub iso: Option<ListServersResponseServersItemIso>,
pub labels: serde_json::Value,
pub load_balancers: Option<Vec<i64>>,
pub location: ListServersResponseServersItemLocation,
pub locked: bool,
pub name: String,
pub outgoing_traffic: Option<i64>,
pub placement_group: Option<ListServersResponseServersItemPlacementGroup>,
pub primary_disk_size: f64,
pub private_net: Vec<ListServersResponseServersItemPrivateNetItem>,
pub protection: ListServersResponseServersItemProtection,
pub public_net: ListServersResponseServersItemPublicNet,
pub rescue_enabled: bool,
pub server_type: ListServersResponseServersItemServerType,
pub status: String,
pub volumes: Option<Vec<i64>>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemImage {
pub architecture: String,
pub bound_to: Option<i64>,
pub created: String,
pub created_from: Option<ListServersResponseServersItemImageCreatedFrom>,
pub deleted: Option<String>,
pub deprecated: Option<String>,
pub description: String,
pub disk_size: f64,
pub id: i64,
pub image_size: Option<f64>,
pub labels: serde_json::Value,
pub name: Option<String>,
pub os_flavor: String,
pub os_version: Option<String>,
pub protection: ListServersResponseServersItemImageProtection,
pub rapid_deploy: Option<bool>,
pub status: String,
#[serde(rename = "type")]
pub r#type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemImageCreatedFrom {
pub id: i64,
pub name: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemImageProtection {
pub delete: bool,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemIso {
pub architecture: Option<String>,
pub deprecation: Option<ListServersResponseServersItemIsoDeprecation>,
pub description: String,
pub id: i64,
pub name: Option<String>,
#[serde(rename = "type")]
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemIsoDeprecation {
pub announced: String,
pub unavailable_after: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemLocation {
pub city: String,
pub country: String,
pub description: String,
pub id: i64,
pub latitude: f64,
pub longitude: f64,
pub name: String,
pub network_zone: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemPlacementGroup {
pub created: String,
pub id: i64,
pub labels: serde_json::Value,
pub name: String,
pub servers: Vec<i64>,
#[serde(rename = "type")]
pub r#type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemPrivateNetItem {
pub alias_ips: Option<Vec<String>>,
pub ip: Option<String>,
pub mac_address: Option<String>,
pub network: Option<i64>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemProtection {
pub delete: bool,
pub rebuild: bool,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemPublicNet {
pub firewalls: Option<Vec<ListServersResponseServersItemPublicNetFirewallsItem>>,
pub floating_ips: Vec<i64>,
pub ipv4: Option<ListServersResponseServersItemPublicNetIpv4>,
pub ipv6: Option<ListServersResponseServersItemPublicNetIpv6>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemPublicNetFirewallsItem {
pub id: Option<i64>,
pub status: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemPublicNetIpv4 {
pub blocked: bool,
pub dns_ptr: String,
pub id: Option<i64>,
pub ip: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemPublicNetIpv6 {
pub blocked: bool,
pub dns_ptr: Option<Vec<ListServersResponseServersItemPublicNetIpv6DnsPtrItem>>,
pub id: Option<i64>,
pub ip: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemPublicNetIpv6DnsPtrItem {
pub dns_ptr: String,
pub ip: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemServerType {
pub architecture: String,
pub category: Option<String>,
pub cores: f64,
pub cpu_type: String,
pub deprecated: bool,
pub deprecation: Option<ListServersResponseServersItemServerTypeDeprecation>,
pub description: String,
pub disk: f64,
pub id: i64,
pub locations: Vec<ListServersResponseServersItemServerTypeLocationsItem>,
pub memory: f64,
pub name: String,
pub prices: Vec<ListServersResponseServersItemServerTypePricesItem>,
pub storage_type: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemServerTypeDeprecation {
pub announced: String,
pub unavailable_after: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemServerTypeLocationsItem {
pub available: bool,
pub deprecation: Option<ListServersResponseServersItemServerTypeLocationsItemDeprecation>,
pub id: i64,
pub name: String,
pub recommended: bool,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemServerTypeLocationsItemDeprecation {
pub announced: String,
pub unavailable_after: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemServerTypePricesItem {
pub included_traffic: i64,
pub location: String,
pub price_hourly: ListServersResponseServersItemServerTypePricesItemPriceHourly,
pub price_monthly: ListServersResponseServersItemServerTypePricesItemPriceMonthly,
pub price_per_tb_traffic: ListServersResponseServersItemServerTypePricesItemPricePerTbTraffic,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemServerTypePricesItemPriceHourly {
pub gross: String,
pub net: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemServerTypePricesItemPriceMonthly {
pub gross: String,
pub net: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonHash)]
pub struct ListServersResponseServersItemServerTypePricesItemPricePerTbTraffic {
pub gross: String,
pub net: String,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct ListServersArgs {
pub name: Option<String>,
pub label_selector: Option<String>,
pub sort: Option<String>,
pub status: Option<String>,
pub page: Option<String>,
pub per_page: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct CreateServerArgs {
pub body: CreateServerRequest,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct GetServerArgs {
pub id: String,
}
#[derive(Debug, Clone, Default, Serialize, JsonHash)]
pub struct DeleteServerArgs {
pub id: String,
}
pub async fn list_servers_request<F>(
client: DynNetClient,
args: &ListServersArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<ListServersResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/servers",
);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.query("name", args.name.as_deref());
builder = builder.query("label_selector", args.label_selector.as_deref());
builder = builder.query("sort", args.sort.as_deref());
builder = builder.query("status", args.status.as_deref());
builder = builder.query("page", args.page.as_deref());
builder = builder.query("per_page", args.per_page.as_deref());
if let Some(f) = builder_mod {
f(&mut builder);
}
let response = client.send_async(builder.build()).await
.map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;
let status: usize = response.get_status().into();
let headers = response.get_headers_ref().clone();
if status < 200 || status >= 300 {
let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
let body = (!error_bytes.is_empty())
.then(|| String::from_utf8_lossy(&error_bytes).into_owned());
return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
}
let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
let parsed: ListServersResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
Ok(ApiResponse { status: status as u16, headers, body: parsed })
}
pub async fn create_server_request<F>(
client: DynNetClient,
args: &CreateServerArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<CreateServerResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/servers",
);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::post(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
builder = builder.body_json(&args.body)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
if let Some(f) = builder_mod {
f(&mut builder);
}
let response = client.send_async(builder.build()).await
.map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;
let status: usize = response.get_status().into();
let headers = response.get_headers_ref().clone();
if status < 200 || status >= 300 {
let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
let body = (!error_bytes.is_empty())
.then(|| String::from_utf8_lossy(&error_bytes).into_owned());
return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
}
let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
let parsed: CreateServerResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
Ok(ApiResponse { status: status as u16, headers, body: parsed })
}
pub async fn get_server_request<F>(
client: DynNetClient,
args: &GetServerArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<GetServerResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/servers/{}",
args.id,
);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::get(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
if let Some(f) = builder_mod {
f(&mut builder);
}
let response = client.send_async(builder.build()).await
.map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;
let status: usize = response.get_status().into();
let headers = response.get_headers_ref().clone();
if status < 200 || status >= 300 {
let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
let body = (!error_bytes.is_empty())
.then(|| String::from_utf8_lossy(&error_bytes).into_owned());
return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
}
let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
let parsed: GetServerResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
Ok(ApiResponse { status: status as u16, headers, body: parsed })
}
pub async fn delete_server_request<F>(
client: DynNetClient,
args: &DeleteServerArgs,
base_url: &str,
builder_mod: Option<F>,
) -> Result<ApiResponse<DeleteServerResponse>, super::shared::ApiError>
where
F: FnOnce(&mut PreparedRequestBuilder),
{
let path = format!("/servers/{}",
args.id,
);
let endpoint_url = format!("{}{}", base_url, path);
let mut builder = PreparedRequestBuilder::delete(&endpoint_url)
.map_err(|e| super::shared::ApiError::RequestBuildFailed(e.to_string()))?;
if let Some(f) = builder_mod {
f(&mut builder);
}
let response = client.send_async(builder.build()).await
.map_err(|e| super::shared::ApiError::RequestSendFailed(e.to_string()))?;
let status: usize = response.get_status().into();
let headers = response.get_headers_ref().clone();
if status < 200 || status >= 300 {
let error_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
let body = (!error_bytes.is_empty())
.then(|| String::from_utf8_lossy(&error_bytes).into_owned());
return Err(super::shared::ApiError::HttpStatus { code: status as u16, headers, body });
}
let body_bytes = foundation_netio::shared::client::body_reader::collect_bytes_from_send_safe(response.take_body());
let parsed: DeleteServerResponse = serde_json::from_slice(&body_bytes).map_err(|e: serde_json::Error| super::shared::ApiError::ParseFailed(e.to_string()))?;
Ok(ApiResponse { status: status as u16, headers, body: parsed })
}