API-Dokumentation

POST_DATA="{
    \"username\": \"user@example.com\",
    \"password\": \"secret\"
}"

curl -X POST "https://fmsid.de/api/login" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
]);

$options = [
    'json' => [
        "username" => "user@example.com",
        "password" => "secret"
    ]
]
$resp = $client->post('login', $options);
echo $resp->getBody();

payload = {
    'username': "user@example.com",
    'password': "secret"
}


req = requests.post('https://fmsid.de/api/login', json=payload)
print(req.json())

POST_DATA="{
    \"method\": \"email_mfa\",
    \"params\": \"No error\"
}"

curl -X POST "https://fmsid.de/api/mfa/challenge" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
]);

$options = [
    'json' => [
        "method" => "email_mfa",
        "params" => "No error"
    ]
]
$resp = $client->post('mfa/challenge', $options);
echo $resp->getBody();

payload = {
    'method': "email_mfa",
    'params': "No error"
}


req = requests.post('https://fmsid.de/api/mfa/challenge', json=payload)
print(req.json())

POST_DATA="{
    \"method\": \"email_mfa\",
    \"payload\": {
        \"code\": \"123456\"
    }
}"

curl -X POST "https://fmsid.de/api/mfa/verify" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
]);

$options = [
    'json' => [
        "method" => "email_mfa",
        "payload" => [
            "code" => "123456"
        ]
    ]
]
$resp = $client->post('mfa/verify', $options);
echo $resp->getBody();

payload = {
    'method': "email_mfa",
    'payload': {
        'code': "123456"
    }
}


req = requests.post('https://fmsid.de/api/mfa/verify', json=payload)
print(req.json())

curl -X POST "https://fmsid.de/api/logout" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->post('logout');
echo $resp->getBody();

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/logout', auth=auth)
print(req.json())

POST_DATA="{
    \"refresh_token\": \"refresh_tokenValue\"
}"

curl -X POST "https://fmsid.de/api/token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
]);

$options = [
    'json' => [
        "refresh_token" => "refresh_tokenValue"
    ]
]
$resp = $client->post('token', $options);
echo $resp->getBody();

payload = {
    'refresh_token': "refresh_tokenValue"
}


req = requests.post('https://fmsid.de/api/token', json=payload)
print(req.json())

POST_DATA="{
    \"refresh_token\": \"refresh_tokenValue\"
}"

curl -X POST "https://fmsid.de/api/revoke" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
]);

$options = [
    'json' => [
        "refresh_token" => "refresh_tokenValue"
    ]
]
$resp = $client->post('revoke', $options);
echo $resp->getBody();

payload = {
    'refresh_token': "refresh_tokenValue"
}


req = requests.post('https://fmsid.de/api/revoke', json=payload)
print(req.json())

curl -X GET "https://fmsid.de/api/details" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('details');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/details', auth=auth)
print(req.json())

POST_DATA="{
    \"email\": \"emailValue\",
    \"firstname\": \"firstnameValue\",
    \"lastname\": \"lastnameValue\",
    \"companyname\": \"companynameValue\",
    \"address1\": \"address1Value\",
    \"address2\": \"address2Value\",
    \"city\": \"cityValue\",
    \"state\": \"stateValue\",
    \"postcode\": \"postcodeValue\",
    \"country\": \"countryValue\",
    \"phonenumber\": \"phonenumberValue\",
    \"type\": \"typeValue\",
    \"mobilephone\": \"mobilephoneValue\"
}"

curl -X PUT "https://fmsid.de/api/details" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "email" => "emailValue",
        "firstname" => "firstnameValue",
        "lastname" => "lastnameValue",
        "companyname" => "companynameValue",
        "address1" => "address1Value",
        "address2" => "address2Value",
        "city" => "cityValue",
        "state" => "stateValue",
        "postcode" => "postcodeValue",
        "country" => "countryValue",
        "phonenumber" => "phonenumberValue",
        "type" => "typeValue",
        "mobilephone" => "mobilephoneValue"
    ]
]
$resp = $client->put('details', $options);
echo $resp->getBody();

payload = {
    'email': "emailValue",
    'firstname': "firstnameValue",
    'lastname': "lastnameValue",
    'companyname': "companynameValue",
    'address1': "address1Value",
    'address2': "address2Value",
    'city': "cityValue",
    'state': "stateValue",
    'postcode': "postcodeValue",
    'country': "countryValue",
    'phonenumber': "phonenumberValue",
    'type': "typeValue",
    'mobilephone': "mobilephoneValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/details', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/logs" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('logs');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/logs', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/affiliates/summary" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('affiliates/summary');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/affiliates/summary', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/affiliates/campaigns" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('affiliates/campaigns');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/affiliates/campaigns', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/affiliates/commissions" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('affiliates/commissions');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/affiliates/commissions', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/affiliates/payouts" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('affiliates/payouts');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/affiliates/payouts', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/affiliates/vouchers" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('affiliates/vouchers');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/affiliates/vouchers', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/affiliates/commissionplans" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('affiliates/commissionplans');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/affiliates/commissionplans', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/contact" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('contact');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/contact', auth=auth)
print(req.json())

POST_DATA="{
    \"password\": \"passwordValue\",
    \"privileges\": \"privilegesValue\",
    \"email\": \"emailValue\",
    \"firstname\": \"firstnameValue\",
    \"lastname\": \"lastnameValue\",
    \"companyname\": \"companynameValue\",
    \"address1\": \"address1Value\",
    \"address2\": \"address2Value\",
    \"city\": \"cityValue\",
    \"state\": \"stateValue\",
    \"postcode\": \"postcodeValue\",
    \"country\": \"countryValue\",
    \"phonenumber\": \"phonenumberValue\",
    \"type\": \"typeValue\",
    \"mobilephone\": \"mobilephoneValue\"
}"

curl -X POST "https://fmsid.de/api/contact" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "password" => "passwordValue",
        "privileges" => "privilegesValue",
        "email" => "emailValue",
        "firstname" => "firstnameValue",
        "lastname" => "lastnameValue",
        "companyname" => "companynameValue",
        "address1" => "address1Value",
        "address2" => "address2Value",
        "city" => "cityValue",
        "state" => "stateValue",
        "postcode" => "postcodeValue",
        "country" => "countryValue",
        "phonenumber" => "phonenumberValue",
        "type" => "typeValue",
        "mobilephone" => "mobilephoneValue"
    ]
]
$resp = $client->post('contact', $options);
echo $resp->getBody();

payload = {
    'password': "passwordValue",
    'privileges': "privilegesValue",
    'email': "emailValue",
    'firstname': "firstnameValue",
    'lastname': "lastnameValue",
    'companyname': "companynameValue",
    'address1': "address1Value",
    'address2': "address2Value",
    'city': "cityValue",
    'state': "stateValue",
    'postcode': "postcodeValue",
    'country': "countryValue",
    'phonenumber': "phonenumberValue",
    'type': "typeValue",
    'mobilephone': "mobilephoneValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/contact', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/contact/privileges" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('contact/privileges');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/contact/privileges', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/contact/@id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('contact/@id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/contact/@id', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"privileges\": \"privilegesValue\",
    \"email\": \"emailValue\",
    \"firstname\": \"firstnameValue\",
    \"lastname\": \"lastnameValue\",
    \"companyname\": \"companynameValue\",
    \"address1\": \"address1Value\",
    \"address2\": \"address2Value\",
    \"city\": \"cityValue\",
    \"state\": \"stateValue\",
    \"postcode\": \"postcodeValue\",
    \"country\": \"countryValue\",
    \"phonenumber\": \"phonenumberValue\",
    \"type\": \"typeValue\",
    \"mobilephone\": \"mobilephoneValue\"
}"

curl -X PUT "https://fmsid.de/api/contact/@id" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "privileges" => "privilegesValue",
        "email" => "emailValue",
        "firstname" => "firstnameValue",
        "lastname" => "lastnameValue",
        "companyname" => "companynameValue",
        "address1" => "address1Value",
        "address2" => "address2Value",
        "city" => "cityValue",
        "state" => "stateValue",
        "postcode" => "postcodeValue",
        "country" => "countryValue",
        "phonenumber" => "phonenumberValue",
        "type" => "typeValue",
        "mobilephone" => "mobilephoneValue"
    ]
]
$resp = $client->put('contact/@id', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'privileges': "privilegesValue",
    'email': "emailValue",
    'firstname': "firstnameValue",
    'lastname': "lastnameValue",
    'companyname': "companynameValue",
    'address1': "address1Value",
    'address2': "address2Value",
    'city': "cityValue",
    'state': "stateValue",
    'postcode': "postcodeValue",
    'country': "countryValue",
    'phonenumber': "phonenumberValue",
    'type': "typeValue",
    'mobilephone': "mobilephoneValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/contact/@id', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/notifications" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('notifications');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/notifications', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/notifications/new" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('notifications/new');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/notifications/new', auth=auth)
print(req.json())

curl -X PUT "https://fmsid.de/api/notifications/@id/ack" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->put('notifications/@id/ack');
echo $resp->getBody();

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/notifications/@id/ack', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/balance" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('balance');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/balance', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/invoice" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('invoice');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/invoice', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/invoice/@id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('invoice/@id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/invoice/@id', auth=auth)
print(req.json())

POST_DATA="{
    \"amount\": \"amountValue\"
}"

curl -X POST "https://fmsid.de/api/invoice/@id/credit" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "amount" => "amountValue"
    ]
]
$resp = $client->post('invoice/@id/credit', $options);
echo $resp->getBody();

payload = {
    'amount': "amountValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/invoice/@id/credit', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/payment" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('payment');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/payment', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/payment/fees" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('payment/fees');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/payment/fees', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/addfunds" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('addfunds');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/addfunds', auth=auth)
print(req.json())

POST_DATA="{
    \"amount\": \"100.00\",
    \"gateway\": \"gatewayValue\"
}"

curl -X POST "https://fmsid.de/api/addfunds" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "amount" => "100.00",
        "gateway" => "gatewayValue"
    ]
]
$resp = $client->post('addfunds', $options);
echo $resp->getBody();

payload = {
    'amount': "100.00",
    'gateway': "gatewayValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/addfunds', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/invoice/@id/pdf" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('invoice/@id/pdf');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/invoice/@id/pdf', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/tickets" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('tickets');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/tickets', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/tickets/@number" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('tickets/@number');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/tickets/@number', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/ticket/attachment/@file" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('ticket/attachment/@file');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/ticket/attachment/@file', auth=auth)
print(req.json())

POST_DATA="{
    \"dept_id\": 1,
    \"subject\": \"Subject\",
    \"body\": \"Message ...\"
}"

curl -X POST "https://fmsid.de/api/tickets" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "dept_id" => 1,
        "subject" => "Subject",
        "body" => "Message ..."
    ]
]
$resp = $client->post('tickets', $options);
echo $resp->getBody();

payload = {
    'dept_id': 1,
    'subject': "Subject",
    'body': "Message ..."
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/tickets', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"number\": \"numberValue\",
    \"body\": \"reply text ..\"
}"

curl -X POST "https://fmsid.de/api/tickets/@number" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "number" => "numberValue",
        "body" => "reply text .."
    ]
]
$resp = $client->post('tickets/@number', $options);
echo $resp->getBody();

payload = {
    'number': "numberValue",
    'body': "reply text .."
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/tickets/@number', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"number\": \"numberValue\"
}"

curl -X PUT "https://fmsid.de/api/tickets/@number/open" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "number" => "numberValue"
    ]
]
$resp = $client->put('tickets/@number/open', $options);
echo $resp->getBody();

payload = {
    'number': "numberValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/tickets/@number/open', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"number\": \"numberValue\"
}"

curl -X PUT "https://fmsid.de/api/tickets/@number/close" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "number" => "numberValue"
    ]
]
$resp = $client->put('tickets/@number/close', $options);
echo $resp->getBody();

payload = {
    'number': "numberValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/tickets/@number/close', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/ticket/departments" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('ticket/departments');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/ticket/departments', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/news" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('news');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/news', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/news/@news_id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('news/@news_id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/news/@news_id', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/knowledgebase" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('knowledgebase');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/knowledgebase', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/knowledgebase/@category_id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('knowledgebase/@category_id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/knowledgebase/@category_id', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/knowledgebase/article/@article_id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('knowledgebase/article/@article_id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/knowledgebase/article/@article_id', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/name/@name" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/name/@name');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/name/@name', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/ns" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/ns');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/ns', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"nameservers\": \"nameserversValue\"
}"

curl -X PUT "https://fmsid.de/api/domain/@id/ns" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "nameservers" => "nameserversValue"
    ]
]
$resp = $client->put('domain/@id/ns', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'nameservers': "nameserversValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/domain/@id/ns', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/reg" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/reg');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/reg', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"action\": \"registerNameServer\",
    \"nameserver\": \"ns1.yourdomain.com\",
    \"ip\": \"1.2.3.4\",
    \"oldip\": \"1.2.3.4\",
    \"newip\": \"5.6.7.8\"
}"

curl -X POST "https://fmsid.de/api/domain/@id/reg" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "action" => "registerNameServer",
        "nameserver" => "ns1.yourdomain.com",
        "ip" => "1.2.3.4",
        "oldip" => "1.2.3.4",
        "newip" => "5.6.7.8"
    ]
]
$resp = $client->post('domain/@id/reg', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'action': "registerNameServer",
    'nameserver': "ns1.yourdomain.com",
    'ip': "1.2.3.4",
    'oldip': "1.2.3.4",
    'newip': "5.6.7.8"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/domain/@id/reg', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/dns" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/dns');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/dns', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"name\": \"nameValue\",
    \"type\": \"typeValue\",
    \"priority\": \"priorityValue\",
    \"content\": \"contentValue\"
}"

curl -X POST "https://fmsid.de/api/domain/@id/dns" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "name" => "nameValue",
        "type" => "typeValue",
        "priority" => "priorityValue",
        "content" => "contentValue"
    ]
]
$resp = $client->post('domain/@id/dns', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'name': "nameValue",
    'type': "typeValue",
    'priority': "priorityValue",
    'content': "contentValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/domain/@id/dns', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"record_id\": \"record_idValue\",
    \"name\": \"nameValue\",
    \"type\": \"typeValue\",
    \"priority\": \"priorityValue\",
    \"content\": \"contentValue\"
}"

curl -X PUT "https://fmsid.de/api/domain/@id/dns/@index" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "record_id" => "record_idValue",
        "name" => "nameValue",
        "type" => "typeValue",
        "priority" => "priorityValue",
        "content" => "contentValue"
    ]
]
$resp = $client->put('domain/@id/dns/@index', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'record_id': "record_idValue",
    'name': "nameValue",
    'type': "typeValue",
    'priority': "priorityValue",
    'content': "contentValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/domain/@id/dns/@index', json=payload, auth=auth)
print(req.json())

curl -X DELETE "https://fmsid.de/api/domain/@id/dns/@index" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->delete('domain/@id/dns/@index');
echo $resp->getBody();

auth=('username', 'password')

req = requests.delete('https://fmsid.de/api/domain/@id/dns/@index', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/dns/types" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/dns/types');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/dns/types', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/epp" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/epp');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/epp', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/sync" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/sync');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/sync', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/reglock" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/reglock');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/reglock', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"switch\": true
}"

curl -X PUT "https://fmsid.de/api/domain/@id/reglock" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "switch" => TRUE
    ]
]
$resp = $client->put('domain/@id/reglock', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'switch': true
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/domain/@id/reglock', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"switch\": true
}"

curl -X PUT "https://fmsid.de/api/domain/@id/idprotection" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "switch" => TRUE
    ]
]
$resp = $client->put('domain/@id/idprotection', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'switch': true
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/domain/@id/idprotection', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/contact" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/contact');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/contact', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"contact_info\": \"contact_infoValue\"
}"

curl -X PUT "https://fmsid.de/api/domain/@id/contact" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "contact_info" => "contact_infoValue"
    ]
]
$resp = $client->put('domain/@id/contact', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'contact_info': "contact_infoValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/domain/@id/contact', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/emforwarding" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/emforwarding');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/emforwarding', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"from\": \"info@domain.com\",
    \"to\": \"destination@domain.com\",
    \"records\": \"recordsValue\"
}"

curl -X PUT "https://fmsid.de/api/domain/@id/emforwarding" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "from" => "info@domain.com",
        "to" => "destination@domain.com",
        "records" => "recordsValue"
    ]
]
$resp = $client->put('domain/@id/emforwarding', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'from': "info@domain.com",
    'to': "destination@domain.com",
    'records': "recordsValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/domain/@id/emforwarding', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\"
}"

curl -X PUT "https://fmsid.de/api/domain/@id/forwarding" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue"
    ]
]
$resp = $client->put('domain/@id/forwarding', $options);
echo $resp->getBody();

payload = {
    'id': "idValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/domain/@id/forwarding', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/autorenew" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/autorenew');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/autorenew', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"autorenew\": \"autorenewValue\"
}"

curl -X PUT "https://fmsid.de/api/domain/@id/autorenew" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "autorenew" => "autorenewValue"
    ]
]
$resp = $client->put('domain/@id/autorenew', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'autorenew': "autorenewValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/domain/@id/autorenew', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/dnssec/flags" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/dnssec/flags');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/dnssec/flags', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/@id/dnssec" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/@id/dnssec');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/@id/dnssec', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\"
}"

curl -X PUT "https://fmsid.de/api/domain/@id/dnssec" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue"
    ]
]
$resp = $client->put('domain/@id/dnssec', $options);
echo $resp->getBody();

payload = {
    'id': "idValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/domain/@id/dnssec', json=payload, auth=auth)
print(req.json())

curl -X DELETE "https://fmsid.de/api/domain/@id/dnssec/@key" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->delete('domain/@id/dnssec/@key');
echo $resp->getBody();

auth=('username', 'password')

req = requests.delete('https://fmsid.de/api/domain/@id/dnssec/@key', auth=auth)
print(req.json())

POST_DATA="{
    \"name\": \"example.com\"
}"

curl -X POST "https://fmsid.de/api/domain/lookup" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "name" => "example.com"
    ]
]
$resp = $client->post('domain/lookup', $options);
echo $resp->getBody();

payload = {
    'name': "example.com"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/domain/lookup', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/order" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/order');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/order', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/domain/order/@id/form" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('domain/order/@id/form');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/domain/order/@id/form', auth=auth)
print(req.json())

POST_DATA="{
    \"name\": \"example.com\",
    \"years\": 1,
    \"action\": \"register\",
    \"tld_id\": 42,
    \"pay_method\": 5,
    \"epp\": \"Syntax error\",
    \"nameservers\": [
        \"ns1.example.com\",
        {
            \"host\": \"ns2.example.com\",
            \"ip\": \"123.234.123.234\"
        }
    ],
    \"registrant\": 42,
    \"admin\": 43,
    \"tech\": 43,
    \"billing\": 42,
    \"data\": {
        \"1618\": {
            \"10330\": \"bar\"
        }
    },
    \"aff_id\": 55
}"

curl -X POST "https://fmsid.de/api/domain/order" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "name" => "example.com",
        "years" => 1,
        "action" => "register",
        "tld_id" => 42,
        "pay_method" => 5,
        "epp" => "Syntax error",
        "nameservers" => [
            "ns1.example.com",
            [
                "host" => "ns2.example.com",
                "ip" => "123.234.123.234"
            ]
        ],
        "registrant" => 42,
        "admin" => 43,
        "tech" => 43,
        "billing" => 42,
        "data" => [
            1618 => [
                10330 => "bar"
            ]
        ],
        "aff_id" => 55
    ]
]
$resp = $client->post('domain/order', $options);
echo $resp->getBody();

payload = {
    'name': "example.com",
    'years': 1,
    'action': "register",
    'tld_id': 42,
    'pay_method': 5,
    'epp': "Syntax error",
    'nameservers': [
        "ns1.example.com",
        {
            'host': "ns2.example.com",
            'ip': "123.234.123.234"
        }
    ],
    'registrant': 42,
    'admin': 43,
    'tech': 43,
    'billing': 42,
    'data': {
        '1618': {
            '10330': "bar"
        }
    },
    'aff_id': 55
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/domain/order', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"years\": \"yearsValue\",
    \"pay_method\": \"pay_methodValue\"
}"

curl -X POST "https://fmsid.de/api/domain/@id/renew" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "years" => "yearsValue",
        "pay_method" => "pay_methodValue"
    ]
]
$resp = $client->post('domain/@id/renew', $options);
echo $resp->getBody();

payload = {
    'years': "yearsValue",
    'pay_method': "pay_methodValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/domain/@id/renew', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/certificate" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('certificate');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/certificate', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/certificate/@service_id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('certificate/@service_id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/certificate/@service_id', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/certificate/@service_id/crt" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('certificate/@service_id/crt');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/certificate/@service_id/crt', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/certificate/order" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('certificate/order');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/certificate/order', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/certificate/order/@product_id/software" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('certificate/order/@product_id/software');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/certificate/order/@product_id/software', auth=auth)
print(req.json())

POST_DATA="{
    \"product_id\": \"product_idValue\",
    \"csr\": \"example.com\",
    \"years\": \"yearsValue\",
    \"pay_method\": \"pay_methodValue\",
    \"approver_email\": \"approver_emailValue\",
    \"admin\": \"adminValue\",
    \"tech\": \"techValue\",
    \"billing\": \"billingValue\",
    \"organization\": \"organizationValue\",
    \"software\": \"softwareValue\",
    \"data\": \"dataValue\",
    \"aff_id\": 55
}"

curl -X POST "https://fmsid.de/api/certificate/order" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "product_id" => "product_idValue",
        "csr" => "example.com",
        "years" => "yearsValue",
        "pay_method" => "pay_methodValue",
        "approver_email" => "approver_emailValue",
        "admin" => "adminValue",
        "tech" => "techValue",
        "billing" => "billingValue",
        "organization" => "organizationValue",
        "software" => "softwareValue",
        "data" => "dataValue",
        "aff_id" => 55
    ]
]
$resp = $client->post('certificate/order', $options);
echo $resp->getBody();

payload = {
    'product_id': "product_idValue",
    'csr': "example.com",
    'years': "yearsValue",
    'pay_method': "pay_methodValue",
    'approver_email': "approver_emailValue",
    'admin': "adminValue",
    'tech': "techValue",
    'billing': "billingValue",
    'organization': "organizationValue",
    'software': "softwareValue",
    'data': "dataValue",
    'aff_id': 55
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/certificate/order', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/methods" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/methods');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/methods', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/upgrade" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/upgrade');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/upgrade', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"resources\": \"resourcesValue\",
    \"package\": \"packageValue\",
    \"cycle\": \"cycleValue\",
    \"send\": \"sendValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/upgrade" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "resources" => "resourcesValue",
        "package" => "packageValue",
        "cycle" => "cycleValue",
        "send" => "sendValue"
    ]
]
$resp = $client->post('service/@id/upgrade', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'resources': "resourcesValue",
    'package': "packageValue",
    'cycle': "cycleValue",
    'send': "sendValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/upgrade', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"immediate\": \"immediateValue\",
    \"reason\": \"reasonValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/cancel" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "immediate" => "immediateValue",
        "reason" => "reasonValue"
    ]
]
$resp = $client->post('service/@id/cancel', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'immediate': "immediateValue",
    'reason': "reasonValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/cancel', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/label" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/label');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/label', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"label\": \"labelValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/label" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "label" => "labelValue"
    ]
]
$resp = $client->post('service/@id/label', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'label': "labelValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/label', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/renew" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue"
    ]
]
$resp = $client->post('service/@id/renew', $options);
echo $resp->getBody();

payload = {
    'id': "idValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/renew', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/cycle" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/cycle');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/cycle', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"cycle\": \"cycleValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/cycle" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "cycle" => "cycleValue"
    ]
]
$resp = $client->post('service/@id/cycle', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'cycle': "cycleValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/cycle', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/vms" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/vms');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/vms', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/vms/@vmid" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/vms/@vmid');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/vms/@vmid', auth=auth)
print(req.json())

POST_DATA="{
    \"label\": \"labelValue\",
    \"template\": \"templateValue\",
    \"memory\": \"memoryValue\",
    \"cpu\": \"cpuValue\",
    \"disk\": \"diskValue\",
    \"interface\": \"interfaceValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/vms" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "label" => "labelValue",
        "template" => "templateValue",
        "memory" => "memoryValue",
        "cpu" => "cpuValue",
        "disk" => "diskValue",
        "interface" => "interfaceValue"
    ]
]
$resp = $client->post('service/@id/vms', $options);
echo $resp->getBody();

payload = {
    'label': "labelValue",
    'template': "templateValue",
    'memory': "memoryValue",
    'cpu': "cpuValue",
    'disk': "diskValue",
    'interface': "interfaceValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/vms', json=payload, auth=auth)
print(req.json())

curl -X DELETE "https://fmsid.de/api/service/@id/vms/@vmid" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->delete('service/@id/vms/@vmid');
echo $resp->getBody();

auth=('username', 'password')

req = requests.delete('https://fmsid.de/api/service/@id/vms/@vmid', auth=auth)
print(req.json())

POST_DATA="{
    \"vmid\": \"vmidValue\",
    \"memory\": \"memoryValue\",
    \"cpu\": \"cpuValue\"
}"

curl -X PUT "https://fmsid.de/api/service/@id/vms/@vmid" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "vmid" => "vmidValue",
        "memory" => "memoryValue",
        "cpu" => "cpuValue"
    ]
]
$resp = $client->put('service/@id/vms/@vmid', $options);
echo $resp->getBody();

payload = {
    'vmid': "vmidValue",
    'memory': "memoryValue",
    'cpu': "cpuValue"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/service/@id/vms/@vmid', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"vmid\": \"vmidValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/vms/@vmid/stop" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "vmid" => "vmidValue"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/stop', $options);
echo $resp->getBody();

payload = {
    'vmid': "vmidValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/vms/@vmid/stop', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"vmid\": \"vmidValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/vms/@vmid/start" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "vmid" => "vmidValue"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/start', $options);
echo $resp->getBody();

payload = {
    'vmid': "vmidValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/vms/@vmid/start', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"vmid\": \"vmidValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/vms/@vmid/shutdown" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "vmid" => "vmidValue"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/shutdown', $options);
echo $resp->getBody();

payload = {
    'vmid': "vmidValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/vms/@vmid/shutdown', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"vmid\": \"vmidValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/vms/@vmid/reboot" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "vmid" => "vmidValue"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/reboot', $options);
echo $resp->getBody();

payload = {
    'vmid': "vmidValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/vms/@vmid/reboot', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"vmid\": \"vmidValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/vms/@vmid/reset" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "vmid" => "vmidValue"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/reset', $options);
echo $resp->getBody();

payload = {
    'vmid': "vmidValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/vms/@vmid/reset', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"hostname\": \"hostnameValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/vms/@vmid/hostname" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "hostname" => "hostnameValue"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/hostname', $options);
echo $resp->getBody();

payload = {
    'hostname': "hostnameValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/vms/@vmid/hostname', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"template\": \"templateValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/vms/@vmid/rebuild" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "template" => "templateValue"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/rebuild', $options);
echo $resp->getBody();

payload = {
    'template': "templateValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/vms/@vmid/rebuild', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/vms/@vmid/ips" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/vms/@vmid/ips');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/vms/@vmid/ips', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/vms/@vmid/ippool" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/vms/@vmid/ippool');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/vms/@vmid/ippool', auth=auth)
print(req.json())

POST_DATA="{
    \"pool\": \"poolValue\",
    \"type\": \"typeValue\",
    \"iface\": \"ifaceValue\",
    \"bridge\": \"bridgeValue\",
    \"number\": \"numberValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/vms/@vmid/ippool/@pool" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "pool" => "poolValue",
        "type" => "typeValue",
        "iface" => "ifaceValue",
        "bridge" => "bridgeValue",
        "number" => "numberValue"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/ippool/@pool', $options);
echo $resp->getBody();

payload = {
    'pool': "poolValue",
    'type': "typeValue",
    'iface': "ifaceValue",
    'bridge': "bridgeValue",
    'number': "numberValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/vms/@vmid/ippool/@pool', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/networks" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/networks');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/networks', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/vms/@vmid/interfaces" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/vms/@vmid/interfaces');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/vms/@vmid/interfaces', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/vms/@vmid/interfaces/@iface" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/vms/@vmid/interfaces/@iface');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/vms/@vmid/interfaces/@iface', auth=auth)
print(req.json())

POST_DATA="{
    \"iface\": \"ifaceValue\",
    \"firewall\": \"firewallValue\",
    \"ipv4\": \"ipv4Value\",
    \"ipv6\": \"ipv6Value\"
}"

curl -X PUT "https://fmsid.de/api/service/@id/vms/@vmid/interfaces/@iface" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "iface" => "ifaceValue",
        "firewall" => "firewallValue",
        "ipv4" => "ipv4Value",
        "ipv6" => "ipv6Value"
    ]
]
$resp = $client->put('service/@id/vms/@vmid/interfaces/@iface', $options);
echo $resp->getBody();

payload = {
    'iface': "ifaceValue",
    'firewall': "firewallValue",
    'ipv4': "ipv4Value",
    'ipv6': "ipv6Value"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/service/@id/vms/@vmid/interfaces/@iface', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"bridge\": \"bridgeValue\",
    \"firewall\": \"firewallValue\",
    \"ipv4\": \"ipv4Value\",
    \"ipv6\": \"ipv6Value\"
}"

curl -X POST "https://fmsid.de/api/service/@id/vms/@vmid/interfaces" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "bridge" => "bridgeValue",
        "firewall" => "firewallValue",
        "ipv4" => "ipv4Value",
        "ipv6" => "ipv6Value"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/interfaces', $options);
echo $resp->getBody();

payload = {
    'bridge': "bridgeValue",
    'firewall': "firewallValue",
    'ipv4': "ipv4Value",
    'ipv6': "ipv6Value"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/vms/@vmid/interfaces', json=payload, auth=auth)
print(req.json())

curl -X DELETE "https://fmsid.de/api/service/@id/vms/@vmid/interfaces/@iface" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->delete('service/@id/vms/@vmid/interfaces/@iface');
echo $resp->getBody();

auth=('username', 'password')

req = requests.delete('https://fmsid.de/api/service/@id/vms/@vmid/interfaces/@iface', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/templates" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/templates');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/templates', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/resources" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/resources');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/resources', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/ip" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/ip');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/ip', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/rdns" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/rdns');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/rdns', auth=auth)
print(req.json())

POST_DATA="{
    \"id\": \"idValue\",
    \"ipaddress\": \"ipaddressValue\"
}"

curl -X POST "https://fmsid.de/api/service/@id/rdns" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "id" => "idValue",
        "ipaddress" => "ipaddressValue"
    ]
]
$resp = $client->post('service/@id/rdns', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'ipaddress': "ipaddressValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@id/rdns', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/bandwidth-graphs" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/bandwidth-graphs');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/bandwidth-graphs', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@id/bandwidth" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@id/bandwidth');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@id/bandwidth', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/category" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('category');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/category', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/category/@category_id/product" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('category/@category_id/product');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/category/@category_id/product', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/order/@product_id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('order/@product_id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/order/@product_id', auth=auth)
print(req.json())

POST_DATA="{
    \"product_id\": 12,
    \"domain\": \"example.com\",
    \"cycle\": \"m\",
    \"pay_method\": \"1\",
    \"custom\": {
        \"1618\": {
            \"10330\": 1
        }
    },
    \"promocode\": \"T346F\",
    \"aff_id\": 55
}"

curl -X POST "https://fmsid.de/api/order/@product_id" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "product_id" => 12,
        "domain" => "example.com",
        "cycle" => "m",
        "pay_method" => "1",
        "custom" => [
            1618 => [
                10330 => 1
            ]
        ],
        "promocode" => "T346F",
        "aff_id" => 55
    ]
]);

$resp = $client->post('order/@product_id', $options);
echo $resp->getBody();

payload = {
    'product_id': 12,
    'domain': "example.com",
    'cycle': "m",
    'pay_method': "1",
    'custom': {
        '1618': {
            '10330': 1
        }
    },
    'promocode': "T346F",
    'aff_id': 55
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/order/@product_id', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"pay_method\": 1,
    \"ignore_errors\": \"No error\",
    \"items\": [
        {
            \"type\": \"product\",
            \"product_id\": 1080,
            \"domain\": \"hosting.com\",
            \"cycle\": \"a\"
        },
        {
            \"type\": \"certificate\",
            \"product_id\": 840,
            \"csr\": \"-----BEGIN CERTIFICATE REQUEST----- (...)\",
            \"years\": 1,
            \"approver_email\": \"admin@hosting.com\"
        },
        {
            \"type\": \"domain\",
            \"tld_id\": 6,
            \"name\": \"hosting.com\",
            \"action\": \"register\",
            \"years\": 1,
            \"nameservers\": [],
            \"registrar\": 42,
            \"data\": []
        },
        {
            \"type\": \"domain\",
            \"domain_id\": 1002,
            \"action\": \"renew\",
            \"years\": 1
        }
    ],
    \"aff_id\": 55
}"

curl -X POST "https://fmsid.de/api/order" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "pay_method" => 1,
        "ignore_errors" => "No error",
        "items" => [
            [
                "type" => "product",
                "product_id" => 1080,
                "domain" => "hosting.com",
                "cycle" => "a"
            ],
            [
                "type" => "certificate",
                "product_id" => 840,
                "csr" => "-----BEGIN CERTIFICATE REQUEST----- (...)",
                "years" => 1,
                "approver_email" => "admin@hosting.com"
            ],
            [
                "type" => "domain",
                "tld_id" => 6,
                "name" => "hosting.com",
                "action" => "register",
                "years" => 1,
                "nameservers" => [

                ],
                "registrar" => 42,
                "data" => [

                ]
            ],
            [
                "type" => "domain",
                "domain_id" => 1002,
                "action" => "renew",
                "years" => 1
            ]
        ],
        "aff_id" => 55
    ]
]
$resp = $client->post('order', $options);
echo $resp->getBody();

payload = {
    'pay_method': 1,
    'ignore_errors': "No error",
    'items': [
        {
            'type': "product",
            'product_id': 1080,
            'domain': "hosting.com",
            'cycle': "a"
        },
        {
            'type': "certificate",
            'product_id': 840,
            'csr': "-----BEGIN CERTIFICATE REQUEST----- (...)",
            'years': 1,
            'approver_email': "admin@hosting.com"
        },
        {
            'type': "domain",
            'tld_id': 6,
            'name': "hosting.com",
            'action': "register",
            'years': 1,
            'nameservers': [],
            'registrar': 42,
            'data': []
        },
        {
            'type': "domain",
            'domain_id': 1002,
            'action': "renew",
            'years': 1
        }
    ],
    'aff_id': 55
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/order', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"pay_method\": \"pay_methodValue\",
    \"output\": \"short\",
    \"items\": [
        {
            \"type\": \"product\",
            \"product_id\": 1080,
            \"domain\": \"hosting.com\",
            \"cycle\": \"a\"
        },
        {
            \"type\": \"certificate\",
            \"product_id\": 840,
            \"csr\": \"-----BEGIN CERTIFICATE REQUEST----- (...)\",
            \"years\": 1,
            \"approver_email\": \"admin@hosting.com\"
        },
        {
            \"type\": \"domain\",
            \"tld_id\": 6,
            \"name\": \"hosting.com\",
            \"action\": \"register\",
            \"years\": 1,
            \"nameservers\": [],
            \"registrar\": 42,
            \"data\": []
        },
        {
            \"type\": \"domain\",
            \"domain_id\": 1002,
            \"action\": \"renew\",
            \"years\": 1
        }
    ]
}"

curl -X POST "https://fmsid.de/api/quote" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "pay_method" => "pay_methodValue",
        "output" => "short",
        "items" => [
            [
                "type" => "product",
                "product_id" => 1080,
                "domain" => "hosting.com",
                "cycle" => "a"
            ],
            [
                "type" => "certificate",
                "product_id" => 840,
                "csr" => "-----BEGIN CERTIFICATE REQUEST----- (...)",
                "years" => 1,
                "approver_email" => "admin@hosting.com"
            ],
            [
                "type" => "domain",
                "tld_id" => 6,
                "name" => "hosting.com",
                "action" => "register",
                "years" => 1,
                "nameservers" => [

                ],
                "registrar" => 42,
                "data" => [

                ]
            ],
            [
                "type" => "domain",
                "domain_id" => 1002,
                "action" => "renew",
                "years" => 1
            ]
        ]
    ]
]
$resp = $client->post('quote', $options);
echo $resp->getBody();

payload = {
    'pay_method': "pay_methodValue",
    'output': "short",
    'items': [
        {
            'type': "product",
            'product_id': 1080,
            'domain': "hosting.com",
            'cycle': "a"
        },
        {
            'type': "certificate",
            'product_id': 840,
            'csr': "-----BEGIN CERTIFICATE REQUEST----- (...)",
            'years': 1,
            'approver_email': "admin@hosting.com"
        },
        {
            'type': "domain",
            'tld_id': 6,
            'name': "hosting.com",
            'action': "register",
            'years': 1,
            'nameservers': [],
            'registrar': 42,
            'data': []
        },
        {
            'type': "domain",
            'domain_id': 1002,
            'action': "renew",
            'years': 1
        }
    ]
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/quote', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/dns" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('dns');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/dns', auth=auth)
print(req.json())

POST_DATA="{
    \"service_id\": \"service_idValue\",
    \"name\": \"testzone.com\",
    \"comment\": \"My zone comment\"
}"

curl -X POST "https://fmsid.de/api/service/@service_id/dns" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "service_id" => "service_idValue",
        "name" => "testzone.com",
        "comment" => "My zone comment"
    ]
]
$resp = $client->post('service/@service_id/dns', $options);
echo $resp->getBody();

payload = {
    'service_id': "service_idValue",
    'name': "testzone.com",
    'comment': "My zone comment"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@service_id/dns', json=payload, auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@service_id/dns" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@service_id/dns');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@service_id/dns', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/service/@service_id/dns/@zone_id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('service/@service_id/dns/@zone_id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/service/@service_id/dns/@zone_id', auth=auth)
print(req.json())

POST_DATA="{
    \"service_id\": \"service_idValue\",
    \"zone_id\": \"zone_idValue\",
    \"comment\": \"My zone comment\"
}"

curl -X PUT "https://fmsid.de/api/service/@service_id/dns/@zone_id" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "service_id" => "service_idValue",
        "zone_id" => "zone_idValue",
        "comment" => "My zone comment"
    ]
]);

$resp = $client->put('service/@service_id/dns/@zone_id', $options);
echo $resp->getBody();

payload = {
    'service_id': "service_idValue",
    'zone_id': "zone_idValue",
    'comment': "My zone comment"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/service/@service_id/dns/@zone_id', json=payload, auth=auth)
print(req.json())

curl -X DELETE "https://fmsid.de/api/service/@service_id/dns/@zone_id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->delete('service/@service_id/dns/@zone_id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.delete('https://fmsid.de/api/service/@service_id/dns/@zone_id', auth=auth)
print(req.json())

POST_DATA="{
    \"service_id\": \"service_idValue\",
    \"zone_id\": \"zone_idValue\",
    \"name\": \"example.com\",
    \"ttl\": 3600,
    \"priority\": 10,
    \"type\": \"A\",
    \"content\": \"192.168.1.2\",
    \"comment\": \"My record comment\"
}"

# OR ...

POST_DATA="{
    \"service_id\": \"service_idValue\",
    \"zone_id\": \"zone_idValue\",
    \"name\": \"_sip._tcp.example.com\",
    \"ttl\": 3600,
    \"priority\": 10,
    \"type\": \"SRV\",
    \"content\": [
        10,
        5060,
        \"vc01.example.com\"
    ],
    \"comment\": \"My record comment\"
}"

curl -X POST "https://fmsid.de/api/service/@service_id/dns/@zone_id/records" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "service_id" => "service_idValue",
        "zone_id" => "zone_idValue",
        "name" => "example.com",
        "ttl" => 3600,
        "priority" => 10,
        "type" => "A",
        "content" => "192.168.1.2",
        "comment" => "My record comment"
    ]
]);

// OR ...

$options = [
    'json' => [
        "service_id" => "service_idValue",
        "zone_id" => "zone_idValue",
        "name" => "_sip._tcp.example.com",
        "ttl" => 3600,
        "priority" => 10,
        "type" => "SRV",
        "content" => [
            10,
            5060,
            "vc01.example.com"
        ],
        "comment" => "My record comment"
    ]
]);

$resp = $client->post('service/@service_id/dns/@zone_id/records', $options);
echo $resp->getBody();

payload = {
    'service_id': "service_idValue",
    'zone_id': "zone_idValue",
    'name': "example.com",
    'ttl': 3600,
    'priority': 10,
    'type': "A",
    'content': "192.168.1.2",
    'comment': "My record comment"
}

# OR ...

payload = {
    'service_id': "service_idValue",
    'zone_id': "zone_idValue",
    'name': "_sip._tcp.example.com",
    'ttl': 3600,
    'priority': 10,
    'type': "SRV",
    'content': [
        10,
        5060,
        "vc01.example.com"
    ],
    'comment': "My record comment"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/service/@service_id/dns/@zone_id/records', json=payload, auth=auth)
print(req.json())

POST_DATA="{
    \"service_id\": \"service_idValue\",
    \"zone_id\": \"zone_idValue\",
    \"record_id\": \"record_idValue\",
    \"name\": \"example.com\",
    \"ttl\": 3600,
    \"priority\": 10,
    \"type\": \"A\",
    \"content\": \"192.168.1.2\",
    \"comment\": \"My record comment\"
}"

curl -X PUT "https://fmsid.de/api/service/@service_id/dns/@zone_id/records/@record_id" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "service_id" => "service_idValue",
        "zone_id" => "zone_idValue",
        "record_id" => "record_idValue",
        "name" => "example.com",
        "ttl" => 3600,
        "priority" => 10,
        "type" => "A",
        "content" => "192.168.1.2",
        "comment" => "My record comment"
    ]
]
$resp = $client->put('service/@service_id/dns/@zone_id/records/@record_id', $options);
echo $resp->getBody();

payload = {
    'service_id': "service_idValue",
    'zone_id': "zone_idValue",
    'record_id': "record_idValue",
    'name': "example.com",
    'ttl': 3600,
    'priority': 10,
    'type': "A",
    'content': "192.168.1.2",
    'comment': "My record comment"
}

auth=('username', 'password')

req = requests.put('https://fmsid.de/api/service/@service_id/dns/@zone_id/records/@record_id', json=payload, auth=auth)
print(req.json())

curl -X DELETE "https://fmsid.de/api/service/@service_id/dns/@zone_id/records/@record_id" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->delete('service/@service_id/dns/@zone_id/records/@record_id');
echo $resp->getBody();

auth=('username', 'password')

req = requests.delete('https://fmsid.de/api/service/@service_id/dns/@zone_id/records/@record_id', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/sms/billing" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('sms/billing');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/sms/billing', auth=auth)
print(req.json())

curl -X GET "https://fmsid.de/api/sms/history" \
   -u user:pass 

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);


$resp = $client->get('sms/history');
echo $resp->getBody();

auth=('username', 'password')

req = requests.get('https://fmsid.de/api/sms/history', auth=auth)
print(req.json())

POST_DATA="{
    \"to\": \"toValue\",
    \"from\": \"fromValue\",
    \"text\": \"textValue\"
}"

curl -X POST "https://fmsid.de/api/sms/send" \
   -u user:pass \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://fmsid.de/api/',
    'auth' => ['username', 'password']
]);

$options = [
    'json' => [
        "to" => "toValue",
        "from" => "fromValue",
        "text" => "textValue"
    ]
]
$resp = $client->post('sms/send', $options);
echo $resp->getBody();

payload = {
    'to': "toValue",
    'from': "fromValue",
    'text': "textValue"
}

auth=('username', 'password')

req = requests.post('https://fmsid.de/api/sms/send', json=payload, auth=auth)
print(req.json())