vps#

reply = api.vps.create({user: 1,
 hostname: "my-vps",
 os_template: 1,
 info: "",
 dns_resolver: 1,
 node: 1,
 onstartall: true})

# reply is an instance of HaveAPI::Client::ResourceInstance
# reply.id = 150

begin
  require 'haveapi/client'

  api = HaveAPI::Client.new("https://api.vpsfree.cz/", version: "7.0")
  api.setup

  api.authenticate(:token, token: 'example-token')

  reply = api.vps.create({user: 1,
   hostname: "my-vps",
   os_template: 1,
   info: "",
   dns_resolver: 1,
   node: 1,
   onstartall: true})

  # reply is an instance of HaveAPI::Client::ResourceInstance
  # reply.id = 150
rescue HaveAPI::Client::ValidationError => error
  warn error.message
  warn error.errors.inspect
rescue HaveAPI::Client::ActionFailed => error
  warn error.message
  warn error.response.errors.inspect if error.response.is_a?(HaveAPI::Client::Response)
rescue HaveAPI::Client::Authentication::AuthenticationFailed, HaveAPI::Client::ProtocolError,
       RestClient::Exception, JSON::ParserError => error
  warn error.message
end

const resource = CallbackClient.findResource(api, ["vps"]);
const action = CallbackClient.findAction(resource, "create");
action.directInvoke({
  params: {["user"]: 1, ["hostname"]: "my-vps", ["os_template"]: 1, ["info"]: "", ["dns_resolver"]: 1, ["node"]: 1, ["onstartall"]: true},
  onReply: (owner, reply) => {
    if (!reply.isOk()) {
      console.error(reply.message(), reply.envelope.errors);
      return;
    }
    console.log(reply.response());
  }
});
// This prints the initial response; use its action-state metadata to monitor completion.

import { CallbackClient } from "haveapi-client";

const api = new CallbackClient("https://api.vpsfree.cz/", {version: "7.0"});

api.authenticate("token", {token: "example-token"}, (api, ready) => {
  if (!ready) {
    console.error("Discovery or authentication failed");
    return;
  }
  try {
    const resource = CallbackClient.findResource(api, ["vps"]);
    const action = CallbackClient.findAction(resource, "create");
    action.directInvoke({
      params: {["user"]: 1, ["hostname"]: "my-vps", ["os_template"]: 1, ["info"]: "", ["dns_resolver"]: 1, ["node"]: 1, ["onstartall"]: true},
      onReply: (owner, reply) => {
        if (!reply.isOk()) {
          console.error(reply.message(), reply.envelope.errors);
          return;
        }
        console.log(reply.response());
        console.log(reply.meta());
      }
    });
    // This prints the initial response; use its action-state metadata to monitor completion.
  } catch (error) {
    console.error(error);
  }
});

const result = await api.resource("vps").action("create")({params: {["user"]: 1, ["hostname"]: "my-vps", ["os_template"]: 1, ["info"]: "", ["dns_resolver"]: 1, ["node"]: 1, ["onstartall"]: true}});
console.log(result.value);
// Request success alone does not establish operation completion.
const completed = await api.waitForCompletion(result, {timeoutMs: 300000});
console.log(completed.state);

import { AsyncClient, AsyncError } from "haveapi-client";

async function main() {
  const api = new AsyncClient("https://api.vpsfree.cz/", {version: "7.0"});
  try {
    await api.authenticate("token", {token: "example-token"});
    const result = await api.resource("vps").action("create")({params: {["user"]: 1, ["hostname"]: "my-vps", ["os_template"]: 1, ["info"]: "", ["dns_resolver"]: 1, ["node"]: 1, ["onstartall"]: true}});
    console.log(result.value);
    console.log(result.response.meta);
    // Request success alone does not establish operation completion.
    const completed = await api.waitForCompletion(result, {timeoutMs: 300000});
    console.log(completed.state);
  } catch (error) {
    if (error instanceof AsyncError) {
      console.error(error.kind, error.message, error.errors);
    } else {
      throw error;
    }
  }
}
main().catch(error => console.error(error));

const resource = CallbackClient.findResource(api, ["vps"]);
const action = CallbackClient.findAction(resource, "create");
action.directInvoke({
  params: {["user"]: 1, ["hostname"]: "my-vps", ["os_template"]: 1, ["info"]: "", ["dns_resolver"]: 1, ["node"]: 1, ["onstartall"]: true},
  onReply: (owner, reply) => {
    if (!reply.isOk()) {
      console.error(reply.message(), reply.envelope.errors);
      return;
    }
    console.log(reply.response());
  }
});
// This prints the initial response; use its action-state metadata to monitor completion.

import { CallbackClient } from "haveapi-client";

const api = new CallbackClient("https://api.vpsfree.cz/", {version: "7.0"});

api.authenticate("token", {token: "example-token"}, (api, ready) => {
  if (!ready) {
    console.error("Discovery or authentication failed");
    return;
  }
  try {
    const resource = CallbackClient.findResource(api, ["vps"]);
    const action = CallbackClient.findAction(resource, "create");
    action.directInvoke({
      params: {["user"]: 1, ["hostname"]: "my-vps", ["os_template"]: 1, ["info"]: "", ["dns_resolver"]: 1, ["node"]: 1, ["onstartall"]: true},
      onReply: (owner, reply) => {
        if (!reply.isOk()) {
          console.error(reply.message(), reply.envelope.errors);
          return;
        }
        console.log(reply.response());
        console.log(reply.meta());
      }
    });
    // This prints the initial response; use its action-state metadata to monitor completion.
  } catch (error) {
    console.error(error);
  }
});

const result = await api.resource("vps").action("create")({params: {["user"]: 1, ["hostname"]: "my-vps", ["os_template"]: 1, ["info"]: "", ["dns_resolver"]: 1, ["node"]: 1, ["onstartall"]: true}});
console.log(result.value);
// Request success alone does not establish operation completion.
const completed = await api.waitForCompletion(result, {timeoutMs: 300000});
console.log(completed.state);

import { AsyncClient, AsyncError } from "haveapi-client";

async function main(): Promise<void> {
  const api = new AsyncClient("https://api.vpsfree.cz/", {version: "7.0"});
  try {
    await api.authenticate("token", {token: "example-token"});
    const result = await api.resource("vps").action("create")({params: {["user"]: 1, ["hostname"]: "my-vps", ["os_template"]: 1, ["info"]: "", ["dns_resolver"]: 1, ["node"]: 1, ["onstartall"]: true}});
    console.log(result.value);
    console.log(result.response.meta);
    // Request success alone does not establish operation completion.
    const completed = await api.waitForCompletion(result, {timeoutMs: 300000});
    console.log(completed.state);
  } catch (error) {
    if (error instanceof AsyncError) {
      console.error(error.kind, error.message, error.errors);
    } else {
      throw error;
    }
  }
}
main().catch(error => console.error(error));

response = api.resources["vps"].actions["create"].call(params={"user": 1, "hostname": "my-vps", "os_template": 1, "info": "", "dns_resolver": 1, "node": 1, "onstartall": True})
print(response.data)
# A request timeout does not cancel a server operation.
if response.operation is not None:
    completed = response.operation.wait(timeout=300, interval=1)
    print(completed)

from haveapi_client import Client, ActionError, HaveAPIError, TokenAuth

try:
    with Client("https://api.vpsfree.cz/", version="7.0", auth=TokenAuth("example-token")) as api:
        response = api.resources["vps"].actions["create"].call(params={"user": 1, "hostname": "my-vps", "os_template": 1, "info": "", "dns_resolver": 1, "node": 1, "onstartall": True})
        print(response.data)
        print(response.meta)
        # A request timeout does not cancel a server operation.
        if response.operation is not None:
            completed = response.operation.wait(timeout=300, interval=1)
            print(completed)
except ActionError as error:
    print(error.message, error.errors)
except HaveAPIError as error:
    print(error.message, error.status_code)

# Run inside an async function after initializing api.
response = await api.resources["vps"].actions["create"].call(params={"user": 1, "hostname": "my-vps", "os_template": 1, "info": "", "dns_resolver": 1, "node": 1, "onstartall": True})
print(response.data)
# A request timeout does not cancel a server operation.
if response.operation is not None:
    completed = await response.operation.wait(timeout=300, interval=1)
    print(completed)

import asyncio

from haveapi_client import AsyncClient, ActionError, HaveAPIError, TokenAuth


async def main() -> None:
    try:
        async with AsyncClient("https://api.vpsfree.cz/", version="7.0", auth=TokenAuth("example-token")) as api:
            response = await api.resources["vps"].actions["create"].call(params={"user": 1, "hostname": "my-vps", "os_template": 1, "info": "", "dns_resolver": 1, "node": 1, "onstartall": True})
            print(response.data)
            print(response.meta)
            # A request timeout does not cancel a server operation.
            if response.operation is not None:
                completed = await response.operation.wait(timeout=300, interval=1)
                print(completed)
    except ActionError as error:
        print(error.message, error.errors)
    except HaveAPIError as error:
        print(error.message, error.status_code)


asyncio.run(main())

invocation := api.Vps.Create.Prepare()
input := invocation.NewInput().SelectParameters()
input.SetUser(1)
input.SetHostname("my-vps")
input.SetOsTemplate(1)
input.SetInfo("")
input.SetDnsResolver(1)
input.SetNode(1)
input.SetOnstartall(true)
response, err := invocation.Call()
if err != nil {
	fmt.Println(err)
	return
}
if !response.Status {
	fmt.Println(response.Message, response.Errors)
	return
}
if response.Output != nil {
	fmt.Println(response.Output.Id)
}
// Request success does not establish operation completion.

// go get github.com/vpsfreecz/vpsadmin-go-client/client@latest
package main

import (
	"fmt"

	client "github.com/vpsfreecz/vpsadmin-go-client/client"
)

func main() {
	api := client.New("https://api.vpsfree.cz")
	invocation := api.Vps.Create.Prepare()
	input := invocation.NewInput().SelectParameters()
	input.SetUser(1)
	input.SetHostname("my-vps")
	input.SetOsTemplate(1)
	input.SetInfo("")
	input.SetDnsResolver(1)
	input.SetNode(1)
	input.SetOnstartall(true)
	// To supply advertised global metadata, select only the fields you set:
	// metadata := invocation.NewMetaInput().SelectParameters()
	// metadata.SetIncludes(value) // value has type string
	// metadata.SetNo(value) // value has type bool
	response, err := invocation.Call()
	if err != nil {
		fmt.Println(err)
		return
	}
	if !response.Status {
		fmt.Println(response.Message, response.Errors)
		return
	}
	if response.Output != nil {
		fmt.Println(response.Output.Id)
	}
	if response.IsBlocking() {
		state, err := response.OperationStatus()
		if err != nil {
			fmt.Println(err)
			return
		}
		if !state.Status {
			fmt.Println(state.Message, state.Errors)
			return
		}
		// Inspect the operation status using its documented output fields.
	}
	// Request success does not establish operation completion.
}

// Use inside an async function returning Result<(), Box<dyn std::error::Error>>.
let response = api.vps().create().user(1_i64).hostname("my-vps".to_owned()).os_template(1_i64).info("".to_owned()).dns_resolver(1_i64).node(1_i64).onstartall(true).send().await?;
println!("{:?}", &response.output.id);
// Request success or a timeout does not establish completion of a server-side operation.

// cargo add vpsadmin-client
// cargo add tokio --features macros,rt-multi-thread
// cargo add serde_json
use vpsadmin_client::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api = match Client::builder("https://api.vpsfree.cz/")
        .basic_auth("user", "secret")
        .build() {
        Ok(api) => api,
        Err(error) => {
            eprintln!("Client configuration failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let response = match api.vps().create().user(1_i64).hostname("my-vps".to_owned()).os_template(1_i64).info("".to_owned()).dns_resolver(1_i64).node(1_i64).onstartall(true).send().await {
        Ok(response) => response,
        Err(error) => {
            eprintln!("Request failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let _ = response.http_status;
    let _ = &response.meta;
    println!("{:?}", &response.output.id);
    // Request success or a timeout does not establish completion of a server-side operation.
    // Use only the separately documented action-state action; this API client has no automatic wait helper.
    Ok(())
}

// Use inside a synchronous function outside async runtime threads returning Result<(), Box<dyn std::error::Error>>.
let response = api.vps().create().user(1_i64).hostname("my-vps".to_owned()).os_template(1_i64).info("".to_owned()).dns_resolver(1_i64).node(1_i64).onstartall(true).send()?;
println!("{:?}", &response.output.id);
// Request success or a timeout does not establish completion of a server-side operation.

// cargo add vpsadmin-client --features blocking
// cargo add serde_json
// Construct, use and drop this blocking client outside async runtime threads.
use vpsadmin_client::blocking::Client;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api = match Client::builder("https://api.vpsfree.cz/")
        .basic_auth("user", "secret")
        .build() {
        Ok(api) => api,
        Err(error) => {
            eprintln!("Client configuration failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let response = match api.vps().create().user(1_i64).hostname("my-vps".to_owned()).os_template(1_i64).info("".to_owned()).dns_resolver(1_i64).node(1_i64).onstartall(true).send() {
        Ok(response) => response,
        Err(error) => {
            eprintln!("Request failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let _ = response.http_status;
    let _ = &response.meta;
    println!("{:?}", &response.output.id);
    // Request success or a timeout does not establish completion of a server-side operation.
    // Use only the separately documented action-state action; this API client has no automatic wait helper.
    Ok(())
}

// Requires an initialized api and an async context.
const result = await api.vps.create({ "params": { "user": 1, "hostname": "my-vps", "os_template": 1, "info": "", "dns_resolver": 1, "node": 1, "onstartall": true } });
console.log(result.data.id);
// Request success does not establish completion of a server-side operation.

// Configured API client: vpsadmin-typescript-client.
import { AsyncClient, AsyncError } from "haveapi-client";
import { createClient } from "vpsadmin-typescript-client";

async function main(): Promise<void> {
  try {
    const runtime = new AsyncClient("https://api.vpsfree.cz/v7.0");
    await runtime.authenticate("basic", { user: "user", password: "secret" });
    const api = createClient({ execute: spec => runtime.request(spec) });
    const result = await api.vps.create({ "params": { "user": 1, "hostname": "my-vps", "os_template": 1, "info": "", "dns_resolver": 1, "node": 1, "onstartall": true } });
    void [result.data, result.meta, result.envelope, result.httpStatus];
    const item = result.data;
    const value0: unknown = item.id;
    if (value0 !== null && value0 !== undefined) console.log(value0);
    // Request success does not establish completion of a server-side operation.
  } catch (error) {
    if (!(error instanceof AsyncError)) throw error;
    console.error(error.kind, error.httpStatus);
    throw error;
  }
}

main().catch(error => { throw error; });

$reply = $api->vps->create([
    'user' => 1,
    'hostname' => 'my-vps',
    'os_template' => 1,
    'info' => '',
    'dns_resolver' => 1,
    'node' => 1,
    'onstartall' => true
]);

// $reply is an instance of \HaveAPI\Client\ResourceInstance
// $reply->id = 150

try {
    $api = new \HaveAPI\Client('https://api.vpsfree.cz/', '7.0');
    $api->setup();

    $api->authenticate('token', ['token' => 'example-token']);

    $reply = $api->vps->create([
        'user' => 1,
        'hostname' => 'my-vps',
        'os_template' => 1,
        'info' => '',
        'dns_resolver' => 1,
        'node' => 1,
        'onstartall' => true
    ]);

    // $reply is an instance of \HaveAPI\Client\ResourceInstance
    // $reply->id = 150
} catch (\HaveAPI\Client\Exception\ValidationError $error) {
    echo $error->getMessage() . "\n";
    print_r($error->getErrors());
} catch (\HaveAPI\Client\Exception\ActionFailed $error) {
    echo $error->getMessage() . "\n";
    print_r($error->getErrors());
} catch (\HaveAPI\Client\Exception\Base $error) {
    echo $error->getMessage() . "\n";
} catch (\Exception $error) {
    // Dependency failures still propagate to the application.
    echo $error->getMessage() . "\n";
    throw $error;
}

$ haveapi-cli -u https://api.vpsfree.cz/ --version 7.0 vps create -- \
              --user 1 \
              --hostname my-vps \
              --os-template 1 \
              --info '' \
              --dns-resolver 1 \
              --node 1 \
              --onstartall
#                              VPS id:  150
#                                User:  -
#                            Hostname:  -
#                     Manage hostname:  -
#                         OS template:  -
#                      Cgroup_version:  -
#                            Map mode:  -
#                                Info:  -
#                        DNS resolver:  -
#                                Node:  -
#                     UID/GID mapping:  -
#                          Auto-start:  -
#                 Auto-start priority:  -
#                        On start all:  -
#                              Config:  -
#                           CPU limit:  -
#                  Start menu timeout:  -
#           Allow admin modifications:  -
#      Enable OS template auto update:  -
#                      Enable network:  -
#                             Dataset:  -
#                                Pool:  -
#                          Created at:  -
#  Implicit_oom_report_rule_hit_count:  -
#                                 CPU:  -
#                          Disk space:  -
#                              Memory:  -
#                                Swap:  -
#                             Running:  -
#                      In rescue mode:  -
#                              Uptime:  -
#                            Loadavg1:  -
#                            Loadavg5:  -
#                           Loadavg15:  -
#                       Process count:  -
#                            Cpu_user:  -
#                            Cpu_nice:  -
#                          Cpu_system:  -
#                            Cpu_idle:  -
#                          Cpu_iowait:  -
#                             Cpu_irq:  -
#                         Cpu_softirq:  -
#                         Used memory:  -
#                           Used swap:  -
#                     Used disk space:  -
#                        Object state:  -
#                          Expiration:  -
#                        Remind after:  -
# 

$ curl --request POST \
       --data-binary \{\"vps\":\{\"user\":1,\"hostname\":\"my-vps\",\"os_template\":1,\"info\":\"\",\"dns_resolver\":1,\"node\":1,\"onstartall\":true\}\} \
       https://api.vpsfree.cz/v7.0/vpses

# {
#   "status": true,
#   "message": null,
#   "response": {
#     "vps": {
#       "id": 150
#     }
#   },
#   "errors": null
# }

POST /v7.0/vpses HTTP/1.1
Host: api.vpsfree.cz
Content-Type: application/json

{
  "vps": {
    "user": 1,
    "hostname": "my-vps",
    "os_template": 1,
    "info": "",
    "dns_resolver": 1,
    "node": 1,
    "onstartall": true
  }
}

HTTP/1.1 200 OK
Content-Type: application/json;charset=utf-8
Content-Length: 113

{
  "status": true,
  "message": null,
  "response": {
    "vps": {
      "id": 150
    }
  },
  "errors": null
}

reply = api.vps.index

# reply is an instance of HaveAPI::Client::ResourceInstanceList,
# which is a subclass of Array

begin
  require 'haveapi/client'

  api = HaveAPI::Client.new("https://api.vpsfree.cz/", version: "7.0")
  api.setup

  api.authenticate(:token, token: 'example-token')

  reply = api.vps.index

  # reply is an instance of HaveAPI::Client::ResourceInstanceList,
  # which is a subclass of Array
rescue HaveAPI::Client::ValidationError => error
  warn error.message
  warn error.errors.inspect
rescue HaveAPI::Client::ActionFailed => error
  warn error.message
  warn error.response.errors.inspect if error.response.is_a?(HaveAPI::Client::Response)
rescue HaveAPI::Client::Authentication::AuthenticationFailed, HaveAPI::Client::ProtocolError,
       RestClient::Exception, JSON::ParserError => error
  warn error.message
end

const resource = CallbackClient.findResource(api, ["vps"]);
const action = CallbackClient.findAction(resource, "index");
action.directInvoke({
  params: {},
  onReply: (owner, reply) => {
    if (!reply.isOk()) {
      console.error(reply.message(), reply.envelope.errors);
      return;
    }
    console.log(reply.response());
  }
});

import { CallbackClient } from "haveapi-client";

const api = new CallbackClient("https://api.vpsfree.cz/", {version: "7.0"});

api.authenticate("token", {token: "example-token"}, (api, ready) => {
  if (!ready) {
    console.error("Discovery or authentication failed");
    return;
  }
  try {
    const resource = CallbackClient.findResource(api, ["vps"]);
    const action = CallbackClient.findAction(resource, "index");
    action.directInvoke({
      params: {},
      onReply: (owner, reply) => {
        if (!reply.isOk()) {
          console.error(reply.message(), reply.envelope.errors);
          return;
        }
        console.log(reply.response());
        console.log(reply.meta());
      }
    });
  } catch (error) {
    console.error(error);
  }
});

const result = await api.resource("vps").action("index")({params: {}});
console.log(result.value);

import { AsyncClient, AsyncError } from "haveapi-client";

async function main() {
  const api = new AsyncClient("https://api.vpsfree.cz/", {version: "7.0"});
  try {
    await api.authenticate("token", {token: "example-token"});
    const result = await api.resource("vps").action("index")({params: {}});
    console.log(result.value);
    console.log(result.response.meta);
  } catch (error) {
    if (error instanceof AsyncError) {
      console.error(error.kind, error.message, error.errors);
    } else {
      throw error;
    }
  }
}
main().catch(error => console.error(error));

const resource = CallbackClient.findResource(api, ["vps"]);
const action = CallbackClient.findAction(resource, "index");
action.directInvoke({
  params: {},
  onReply: (owner, reply) => {
    if (!reply.isOk()) {
      console.error(reply.message(), reply.envelope.errors);
      return;
    }
    console.log(reply.response());
  }
});

import { CallbackClient } from "haveapi-client";

const api = new CallbackClient("https://api.vpsfree.cz/", {version: "7.0"});

api.authenticate("token", {token: "example-token"}, (api, ready) => {
  if (!ready) {
    console.error("Discovery or authentication failed");
    return;
  }
  try {
    const resource = CallbackClient.findResource(api, ["vps"]);
    const action = CallbackClient.findAction(resource, "index");
    action.directInvoke({
      params: {},
      onReply: (owner, reply) => {
        if (!reply.isOk()) {
          console.error(reply.message(), reply.envelope.errors);
          return;
        }
        console.log(reply.response());
        console.log(reply.meta());
      }
    });
  } catch (error) {
    console.error(error);
  }
});

const result = await api.resource("vps").action("index")({params: {}});
console.log(result.value);

import { AsyncClient, AsyncError } from "haveapi-client";

async function main(): Promise<void> {
  const api = new AsyncClient("https://api.vpsfree.cz/", {version: "7.0"});
  try {
    await api.authenticate("token", {token: "example-token"});
    const result = await api.resource("vps").action("index")({params: {}});
    console.log(result.value);
    console.log(result.response.meta);
  } catch (error) {
    if (error instanceof AsyncError) {
      console.error(error.kind, error.message, error.errors);
    } else {
      throw error;
    }
  }
}
main().catch(error => console.error(error));

response = api.resources["vps"].actions["index"].call(params={})
print(response.data)

from haveapi_client import Client, ActionError, HaveAPIError, TokenAuth

try:
    with Client("https://api.vpsfree.cz/", version="7.0", auth=TokenAuth("example-token")) as api:
        response = api.resources["vps"].actions["index"].call(params={})
        print(response.data)
        print(response.meta)
except ActionError as error:
    print(error.message, error.errors)
except HaveAPIError as error:
    print(error.message, error.status_code)

# Run inside an async function after initializing api.
response = await api.resources["vps"].actions["index"].call(params={})
print(response.data)

import asyncio

from haveapi_client import AsyncClient, ActionError, HaveAPIError, TokenAuth


async def main() -> None:
    try:
        async with AsyncClient("https://api.vpsfree.cz/", version="7.0", auth=TokenAuth("example-token")) as api:
            response = await api.resources["vps"].actions["index"].call(params={})
            print(response.data)
            print(response.meta)
    except ActionError as error:
        print(error.message, error.errors)
    except HaveAPIError as error:
        print(error.message, error.status_code)


asyncio.run(main())

invocation := api.Vps.Index.Prepare()
invocation.NewInput().SelectParameters()
response, err := invocation.Call()
if err != nil {
	fmt.Println(err)
	return
}
if !response.Status {
	fmt.Println(response.Message, response.Errors)
	return
}
for _, item := range response.Output {
	if item != nil {
		fmt.Println(item.Id)
		if item.User != nil {
			fmt.Println(item.User.Id)
			fmt.Println(item.User.Login)
		}
		fmt.Println(item.Hostname)
		if item.OsTemplate != nil {
			fmt.Println(item.OsTemplate.Id)
			fmt.Println(item.OsTemplate.Label)
		}
		fmt.Println(item.Info)
		if item.DnsResolver != nil {
			fmt.Println(item.DnsResolver.Id)
		}
		if item.Node != nil {
			fmt.Println(item.Node.Id)
			fmt.Println(item.Node.Name)
		}
		fmt.Println(item.Onstartall)
	}
}

// Use inside an async function returning Result<(), Box<dyn std::error::Error>>.
let response = api.vps().index().send().await?;
for item in &response.output {
    println!("{:?}", &item.id);
    println!("{:?}", &item.user);
    println!("{:?}", &item.hostname);
    println!("{:?}", &item.os_template);
    println!("{:?}", &item.info);
    println!("{:?}", &item.dns_resolver);
    println!("{:?}", &item.node);
    println!("{:?}", &item.onstartall);
}

// cargo add vpsadmin-client
// cargo add tokio --features macros,rt-multi-thread
// cargo add serde_json
use vpsadmin_client::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api = match Client::builder("https://api.vpsfree.cz/")
        .basic_auth("user", "secret")
        .build() {
        Ok(api) => api,
        Err(error) => {
            eprintln!("Client configuration failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let response = match api.vps().index().send().await {
        Ok(response) => response,
        Err(error) => {
            eprintln!("Request failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let _ = response.http_status;
    let _ = &response.meta;
    for item in &response.output {
        println!("{:?}", &item.id);
        println!("{:?}", &item.user);
        println!("{:?}", &item.hostname);
        println!("{:?}", &item.os_template);
        println!("{:?}", &item.info);
        println!("{:?}", &item.dns_resolver);
        println!("{:?}", &item.node);
        println!("{:?}", &item.onstartall);
    }
    Ok(())
}

// Use inside a synchronous function outside async runtime threads returning Result<(), Box<dyn std::error::Error>>.
let response = api.vps().index().send()?;
for item in &response.output {
    println!("{:?}", &item.id);
    println!("{:?}", &item.user);
    println!("{:?}", &item.hostname);
    println!("{:?}", &item.os_template);
    println!("{:?}", &item.info);
    println!("{:?}", &item.dns_resolver);
    println!("{:?}", &item.node);
    println!("{:?}", &item.onstartall);
}

// cargo add vpsadmin-client --features blocking
// cargo add serde_json
// Construct, use and drop this blocking client outside async runtime threads.
use vpsadmin_client::blocking::Client;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api = match Client::builder("https://api.vpsfree.cz/")
        .basic_auth("user", "secret")
        .build() {
        Ok(api) => api,
        Err(error) => {
            eprintln!("Client configuration failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let response = match api.vps().index().send() {
        Ok(response) => response,
        Err(error) => {
            eprintln!("Request failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let _ = response.http_status;
    let _ = &response.meta;
    for item in &response.output {
        println!("{:?}", &item.id);
        println!("{:?}", &item.user);
        println!("{:?}", &item.hostname);
        println!("{:?}", &item.os_template);
        println!("{:?}", &item.info);
        println!("{:?}", &item.dns_resolver);
        println!("{:?}", &item.node);
        println!("{:?}", &item.onstartall);
    }
    Ok(())
}

// Requires an initialized api and an async context.
const result = await api.vps.index();
for (const item of result.data) {
  console.log(item.id);
  console.log(item.user);
  console.log(item.hostname);
  console.log(item.os_template);
  console.log(item.info);
  console.log(item.dns_resolver);
  console.log(item.node);
  console.log(item.onstartall);
}

// Configured API client: vpsadmin-typescript-client.
import { AsyncClient, AsyncError } from "haveapi-client";
import { createClient } from "vpsadmin-typescript-client";

async function main(): Promise<void> {
  try {
    const runtime = new AsyncClient("https://api.vpsfree.cz/v7.0");
    await runtime.authenticate("basic", { user: "user", password: "secret" });
    const api = createClient({ execute: spec => runtime.request(spec) });
    const result = await api.vps.index();
    void [result.data, result.meta, result.envelope, result.httpStatus];
    for (const item of result.data) {
      const value0: unknown = item.id;
      if (value0 !== null && value0 !== undefined) console.log(value0);
      const value1: unknown = item.user;
      if (value1 !== null && value1 !== undefined) console.log(value1);
      const value2: unknown = item.hostname;
      if (value2 !== null && value2 !== undefined) console.log(value2);
      const value3: unknown = item.os_template;
      if (value3 !== null && value3 !== undefined) console.log(value3);
      const value4: unknown = item.info;
      if (value4 !== null && value4 !== undefined) console.log(value4);
      const value5: unknown = item.dns_resolver;
      if (value5 !== null && value5 !== undefined) console.log(value5);
      const value6: unknown = item.node;
      if (value6 !== null && value6 !== undefined) console.log(value6);
      const value7: unknown = item.onstartall;
      if (value7 !== null && value7 !== undefined) console.log(value7);
    }
  } catch (error) {
    if (!(error instanceof AsyncError)) throw error;
    console.error(error.kind, error.httpStatus);
    throw error;
  }
}

main().catch(error => { throw error; });

$reply = $api->vps->index();

// $reply is an instance of \HaveAPI\Client\ResourceInstanceList

try {
    $api = new \HaveAPI\Client('https://api.vpsfree.cz/', '7.0');
    $api->setup();

    $api->authenticate('token', ['token' => 'example-token']);

    $reply = $api->vps->index();

    // $reply is an instance of \HaveAPI\Client\ResourceInstanceList
} catch (\HaveAPI\Client\Exception\ValidationError $error) {
    echo $error->getMessage() . "\n";
    print_r($error->getErrors());
} catch (\HaveAPI\Client\Exception\ActionFailed $error) {
    echo $error->getMessage() . "\n";
    print_r($error->getErrors());
} catch (\HaveAPI\Client\Exception\Base $error) {
    echo $error->getMessage() . "\n";
} catch (\Exception $error) {
    // Dependency failures still propagate to the application.
    echo $error->getMessage() . "\n";
    throw $error;
}

$ haveapi-cli -u https://api.vpsfree.cz/ --version 7.0 vps index
#                              VPS id:  150
#                                User:  somebody (#1)
#                            Hostname:  thehostname
#                     Manage hostname:  -
#                         OS template:  Scientific Linux 6 (#1)
#                      Cgroup_version:  -
#                            Map mode:  -
#                                Info:  My very important VPS
#                        DNS resolver:   (#1)
#                                Node:   (#1)
#                     UID/GID mapping:  -
#                          Auto-start:  -
#                 Auto-start priority:  -
#                        On start all:  true
#                              Config:  -
#                           CPU limit:  -
#                  Start menu timeout:  -
#           Allow admin modifications:  -
#      Enable OS template auto update:  -
#                      Enable network:  -
#                             Dataset:  -
#                                Pool:  -
#                          Created at:  -
#  Implicit_oom_report_rule_hit_count:  -
#                                 CPU:  -
#                          Disk space:  -
#                              Memory:  -
#                                Swap:  -
#                             Running:  -
#                      In rescue mode:  -
#                              Uptime:  -
#                            Loadavg1:  -
#                            Loadavg5:  -
#                           Loadavg15:  -
#                       Process count:  -
#                            Cpu_user:  -
#                            Cpu_nice:  -
#                          Cpu_system:  -
#                            Cpu_idle:  -
#                          Cpu_iowait:  -
#                             Cpu_irq:  -
#                         Cpu_softirq:  -
#                         Used memory:  -
#                           Used swap:  -
#                     Used disk space:  -
#                    Maintenance lock:  -
#                  Maintenance reason:  -
#                        Object state:  -
#                          Expiration:  -
#                        Remind after:  -
# 

$ curl --request GET \
       --data-binary \{\"vps\":\{\}\} \
       https://api.vpsfree.cz/v7.0/vpses

# {
#   "status": true,
#   "message": null,
#   "response": {
#     "vpses": [
#       {
#         "id": 150,
#         "user": {
#           "id": 1,
#           "login": "somebody"
#         },
#         "hostname": "thehostname",
#         "os_template": {
#           "id": 1,
#           "label": "Scientific Linux 6"
#         },
#         "info": "My very important VPS",
#         "dns_resolver": {
#           "id": 1
#         },
#         "node": {
#           "id": 1,
#           "name": "node1"
#         },
#         "onstartall": true
#       }
#     ]
#   },
#   "errors": null
# }

GET /v7.0/vpses HTTP/1.1
Host: api.vpsfree.cz
Content-Type: application/json



HTTP/1.1 200 OK
Content-Type: application/json;charset=utf-8
Content-Length: 539

{
  "status": true,
  "message": null,
  "response": {
    "vpses": [
      {
        "id": 150,
        "user": {
          "id": 1,
          "login": "somebody"
        },
        "hostname": "thehostname",
        "os_template": {
          "id": 1,
          "label": "Scientific Linux 6"
        },
        "info": "My very important VPS",
        "dns_resolver": {
          "id": 1
        },
        "node": {
          "id": 1,
          "name": "node1"
        },
        "onstartall": true
      }
    ]
  },
  "errors": null
}