BergamotClient.java

package com.intrbiz.bergamot;

import com.intrbiz.bergamot.credentials.*;
import com.intrbiz.bergamot.*;
import com.intrbiz.bergamot.model.message.*;
import com.intrbiz.bergamot.model.message.AlertMO;
import com.intrbiz.bergamot.model.message.AuthTokenMO;
import com.intrbiz.bergamot.model.message.CheckMO;
import com.intrbiz.bergamot.model.message.ClusterMO;
import com.intrbiz.bergamot.model.message.CommandMO;
import com.intrbiz.bergamot.model.message.CommentMO;
import com.intrbiz.bergamot.model.message.ContactMO;
import com.intrbiz.bergamot.model.message.DowntimeMO;
import com.intrbiz.bergamot.model.message.GroupMO;
import com.intrbiz.bergamot.model.message.HostMO;
import com.intrbiz.bergamot.model.message.LocationMO;
import com.intrbiz.bergamot.model.message.ResourceMO;
import com.intrbiz.bergamot.model.message.ServiceMO;
import com.intrbiz.bergamot.model.message.TeamMO;
import com.intrbiz.bergamot.model.message.TimePeriodMO;
import com.intrbiz.bergamot.model.message.TrapMO;
import com.intrbiz.bergamot.model.message.reading.CheckReadingMO;
import com.intrbiz.bergamot.model.message.state.CheckStateMO;
import com.intrbiz.bergamot.model.message.state.CheckTransitionMO;
import java.io.IOException;
import java.lang.Boolean;
import java.lang.Integer;
import java.lang.Long;
import java.lang.String;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import org.apache.http.client.fluent.*;

public class BergamotClient extends BaseBergamotClient
{

    public BergamotClient(String baseURL, ClientCredentials credentials)
    {
        super(baseURL, credentials);
    }

    public BergamotClient(String baseURL, String username, String password)
    {
        super(baseURL, username, password);
    }

    public BergamotClient(String baseURL, String token)
    {
        super(baseURL, token);
    }

    public BergamotClient(String baseURL)
    {
        super(baseURL);
    }



    public static class ChangePasswordCall extends BergamotAPICall<Boolean>
    {

        private String currentPassword;

        private String newPassword;

        public ChangePasswordCall(BaseBergamotClient client)
        {
            super(client);
        }


        public ChangePasswordCall currentPassword(String currentPassword)
        {
            this.currentPassword = currentPassword;
            return this;
        }

        public ChangePasswordCall newPassword(String newPassword)
        {
            this.newPassword = newPassword;
            return this;
        }

        public Boolean execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/change-password"))
                    .addHeader(authHeader())
                    .bodyForm(
                        param("current-password", this.currentPassword),
                        param("new-password", this.newPassword)
                    )
                );
                return transcoder().decodeFromString(response.returnContent().asString(), Boolean.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public ChangePasswordCall callChangePassword()
    {
        return new ChangePasswordCall(this);
    }



    public static class GetAppAuthTokenCall extends BergamotAPICall<AuthTokenMO>
    {

        private String appName;

        private String username;

        private String password;

        public GetAppAuthTokenCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetAppAuthTokenCall appName(String appName)
        {
            this.appName = appName;
            return this;
        }

        public GetAppAuthTokenCall username(String username)
        {
            this.username = username;
            return this;
        }

        public GetAppAuthTokenCall password(String password)
        {
            this.password = password;
            return this;
        }

        public AuthTokenMO execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/app/auth-token"))
                    .addHeader(authHeader())
                    .bodyForm(
                        param("app", this.appName),
                        param("username", this.username),
                        param("password", this.password)
                    )
                );
                return transcoder().decodeFromString(response.returnContent().asString(), AuthTokenMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetAppAuthTokenCall callGetAppAuthToken()
    {
        return new GetAppAuthTokenCall(this);
    }



    public static class ExtendAuthTokenCall extends BergamotAPICall<AuthTokenMO>
    {

        private String token;

        public ExtendAuthTokenCall(BaseBergamotClient client)
        {
            super(client);
        }


        public ExtendAuthTokenCall token(String token)
        {
            this.token = token;
            return this;
        }

        public AuthTokenMO execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/extend-auth-token"))
                    .addHeader(authHeader())
                    .bodyForm(
                        param("auth-token", this.token)
                    )
                );
                return transcoder().decodeFromString(response.returnContent().asString(), AuthTokenMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public ExtendAuthTokenCall callExtendAuthToken()
    {
        return new ExtendAuthTokenCall(this);
    }



    public static class GetCurrentAlertForCheckCall extends BergamotAPICall<AlertMO>
    {

        private UUID id;

        public GetCurrentAlertForCheckCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetCurrentAlertForCheckCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public AlertMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/alert/current/for-check/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), AlertMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetCurrentAlertForCheckCall callGetCurrentAlertForCheck()
    {
        return new GetCurrentAlertForCheckCall(this);
    }



    public static class AcknowledgeAlertCall extends BergamotAPICall<AlertMO>
    {

        private UUID id;

        private String summary;

        private String comment;

        public AcknowledgeAlertCall(BaseBergamotClient client)
        {
            super(client);
        }


        public AcknowledgeAlertCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public AcknowledgeAlertCall summary(String summary)
        {
            this.summary = summary;
            return this;
        }

        public AcknowledgeAlertCall comment(String comment)
        {
            this.comment = comment;
            return this;
        }

        public AlertMO execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/alert/id/" + this.id + "/acknowledge"))
                    .addHeader(authHeader())
                    .bodyForm(
                        param("summary", this.summary),
                        param("comment", this.comment)
                    )
                );
                return transcoder().decodeFromString(response.returnContent().asString(), AlertMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public AcknowledgeAlertCall callAcknowledgeAlert()
    {
        return new AcknowledgeAlertCall(this);
    }



    public static class GetAlertsCall extends BergamotAPICall<List<AlertMO>>
    {

        public GetAlertsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<AlertMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/alert/"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), AlertMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetAlertsCall callGetAlerts()
    {
        return new GetAlertsCall(this);
    }



    public static class GetAlertCall extends BergamotAPICall<AlertMO>
    {

        private UUID id;

        public GetAlertCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetAlertCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public AlertMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/alert/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), AlertMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetAlertCall callGetAlert()
    {
        return new GetAlertCall(this);
    }



    public static class GetAlertsForCheckCall extends BergamotAPICall<List<AlertMO>>
    {

        private UUID id;

        public GetAlertsForCheckCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetAlertsForCheckCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<AlertMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/alert/for-check/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), AlertMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetAlertsForCheckCall callGetAlertsForCheck()
    {
        return new GetAlertsForCheckCall(this);
    }



    public static class GetHostByNameCall extends BergamotAPICall<HostMO>
    {

        private String name;

        public GetHostByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetHostByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public HostMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/name/" + this.name + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), HostMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetHostByNameCall callGetHostByName()
    {
        return new GetHostByNameCall(this);
    }



    public static class ExecuteHostCall extends BergamotAPICall<String>
    {

        private UUID id;

        public ExecuteHostCall(BaseBergamotClient client)
        {
            super(client);
        }


        public ExecuteHostCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/execute"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public ExecuteHostCall callExecuteHost()
    {
        return new ExecuteHostCall(this);
    }



    public static class ExecuteServicesOnHostCall extends BergamotAPICall<String>
    {

        private UUID id;

        public ExecuteServicesOnHostCall(BaseBergamotClient client)
        {
            super(client);
        }


        public ExecuteServicesOnHostCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/execute-services"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public ExecuteServicesOnHostCall callExecuteServicesOnHost()
    {
        return new ExecuteServicesOnHostCall(this);
    }



    public static class SuppressServicesOnHostCall extends BergamotAPICall<String>
    {

        private UUID id;

        public SuppressServicesOnHostCall(BaseBergamotClient client)
        {
            super(client);
        }


        public SuppressServicesOnHostCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/suppress-services"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public SuppressServicesOnHostCall callSuppressServicesOnHost()
    {
        return new SuppressServicesOnHostCall(this);
    }



    public static class UnsuppressServicesOnHostCall extends BergamotAPICall<String>
    {

        private UUID id;

        public UnsuppressServicesOnHostCall(BaseBergamotClient client)
        {
            super(client);
        }


        public UnsuppressServicesOnHostCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/unsuppress-services"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public UnsuppressServicesOnHostCall callUnsuppressServicesOnHost()
    {
        return new UnsuppressServicesOnHostCall(this);
    }



    public static class GetHostsCall extends BergamotAPICall<List<HostMO>>
    {

        public GetHostsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<HostMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), HostMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetHostsCall callGetHosts()
    {
        return new GetHostsCall(this);
    }



    public static class SuppressCall extends BergamotAPICall<String>
    {

        private UUID id;

        public SuppressCall(BaseBergamotClient client)
        {
            super(client);
        }


        public SuppressCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/suppress"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public SuppressCall callSuppress()
    {
        return new SuppressCall(this);
    }



    public static class UnsuppressCall extends BergamotAPICall<String>
    {

        private UUID id;

        public UnsuppressCall(BaseBergamotClient client)
        {
            super(client);
        }


        public UnsuppressCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/unsuppress"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public UnsuppressCall callUnsuppress()
    {
        return new UnsuppressCall(this);
    }



    public static class GetHostStateByNameCall extends BergamotAPICall<CheckStateMO>
    {

        private String name;

        public GetHostStateByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetHostStateByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public CheckStateMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/name/" + this.name + "/state"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CheckStateMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetHostStateByNameCall callGetHostStateByName()
    {
        return new GetHostStateByNameCall(this);
    }



    public static class GetHostStateCall extends BergamotAPICall<CheckStateMO>
    {

        private UUID id;

        public GetHostStateCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetHostStateCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public CheckStateMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/state"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CheckStateMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetHostStateCall callGetHostState()
    {
        return new GetHostStateCall(this);
    }



    public static class GetHostServicesByNameCall extends BergamotAPICall<List<ServiceMO>>
    {

        private String name;

        public GetHostServicesByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetHostServicesByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public List<ServiceMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/name/" + this.name + "/services"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), ServiceMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetHostServicesByNameCall callGetHostServicesByName()
    {
        return new GetHostServicesByNameCall(this);
    }



    public static class GetHostServicesCall extends BergamotAPICall<List<ServiceMO>>
    {

        private UUID id;

        public GetHostServicesCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetHostServicesCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<ServiceMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/services"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), ServiceMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetHostServicesCall callGetHostServices()
    {
        return new GetHostServicesCall(this);
    }



    public static class GetHostTrapsByNameCall extends BergamotAPICall<List<TrapMO>>
    {

        private String name;

        public GetHostTrapsByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetHostTrapsByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public List<TrapMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/name/" + this.name + "/traps"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), TrapMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetHostTrapsByNameCall callGetHostTrapsByName()
    {
        return new GetHostTrapsByNameCall(this);
    }



    public static class GetHostTrapsCall extends BergamotAPICall<List<TrapMO>>
    {

        private UUID id;

        public GetHostTrapsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetHostTrapsCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<TrapMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/traps"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), TrapMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetHostTrapsCall callGetHostTraps()
    {
        return new GetHostTrapsCall(this);
    }



    public static class SuppressTrapsOnHostCall extends BergamotAPICall<String>
    {

        private UUID id;

        public SuppressTrapsOnHostCall(BaseBergamotClient client)
        {
            super(client);
        }


        public SuppressTrapsOnHostCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/suppress-traps"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public SuppressTrapsOnHostCall callSuppressTrapsOnHost()
    {
        return new SuppressTrapsOnHostCall(this);
    }



    public static class UnsuppressTrapsOnHostCall extends BergamotAPICall<String>
    {

        private UUID id;

        public UnsuppressTrapsOnHostCall(BaseBergamotClient client)
        {
            super(client);
        }


        public UnsuppressTrapsOnHostCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/unsuppress-traps"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public UnsuppressTrapsOnHostCall callUnsuppressTrapsOnHost()
    {
        return new UnsuppressTrapsOnHostCall(this);
    }



    public static class SuppressAllOnHostCall extends BergamotAPICall<String>
    {

        private UUID id;

        public SuppressAllOnHostCall(BaseBergamotClient client)
        {
            super(client);
        }


        public SuppressAllOnHostCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/suppress-all"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public SuppressAllOnHostCall callSuppressAllOnHost()
    {
        return new SuppressAllOnHostCall(this);
    }



    public static class UnsuppressAllOnHostCall extends BergamotAPICall<String>
    {

        private UUID id;

        public UnsuppressAllOnHostCall(BaseBergamotClient client)
        {
            super(client);
        }


        public UnsuppressAllOnHostCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + "/unsuppress-all"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public UnsuppressAllOnHostCall callUnsuppressAllOnHost()
    {
        return new UnsuppressAllOnHostCall(this);
    }



    public static class GetHostCall extends BergamotAPICall<HostMO>
    {

        private UUID id;

        public GetHostCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetHostCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public HostMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/host/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), HostMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetHostCall callGetHost()
    {
        return new GetHostCall(this);
    }



    public static class GetRootLocationsCall extends BergamotAPICall<List<LocationMO>>
    {

        public GetRootLocationsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<LocationMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/location/roots"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), LocationMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetRootLocationsCall callGetRootLocations()
    {
        return new GetRootLocationsCall(this);
    }



    public static class GetLocationByNameCall extends BergamotAPICall<LocationMO>
    {

        private String name;

        public GetLocationByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetLocationByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public LocationMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/location/name/" + this.name + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), LocationMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetLocationByNameCall callGetLocationByName()
    {
        return new GetLocationByNameCall(this);
    }



    public static class ExecuteHostsInLocationCall extends BergamotAPICall<String>
    {

        private UUID id;

        public ExecuteHostsInLocationCall(BaseBergamotClient client)
        {
            super(client);
        }


        public ExecuteHostsInLocationCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/location/id/" + this.id + "/execute-all-hosts"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public ExecuteHostsInLocationCall callExecuteHostsInLocation()
    {
        return new ExecuteHostsInLocationCall(this);
    }



    public static class GetLocationsCall extends BergamotAPICall<List<LocationMO>>
    {

        public GetLocationsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<LocationMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/location/"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), LocationMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetLocationsCall callGetLocations()
    {
        return new GetLocationsCall(this);
    }



    public static class GetLocationChildrenByNameCall extends BergamotAPICall<List<LocationMO>>
    {

        private String name;

        public GetLocationChildrenByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetLocationChildrenByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public List<LocationMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/location/name/" + this.name + "/children"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), LocationMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetLocationChildrenByNameCall callGetLocationChildrenByName()
    {
        return new GetLocationChildrenByNameCall(this);
    }



    public static class GetLocationHostsByNameCall extends BergamotAPICall<List<HostMO>>
    {

        private String name;

        public GetLocationHostsByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetLocationHostsByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public List<HostMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/location/name/" + this.name + "/hosts"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), HostMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetLocationHostsByNameCall callGetLocationHostsByName()
    {
        return new GetLocationHostsByNameCall(this);
    }



    public static class GetLocationChildrenCall extends BergamotAPICall<List<LocationMO>>
    {

        private UUID id;

        public GetLocationChildrenCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetLocationChildrenCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<LocationMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/location/id/" + this.id + "/children"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), LocationMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetLocationChildrenCall callGetLocationChildren()
    {
        return new GetLocationChildrenCall(this);
    }



    public static class GetLocationHostsCall extends BergamotAPICall<List<HostMO>>
    {

        private UUID id;

        public GetLocationHostsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetLocationHostsCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<HostMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/location/id/" + this.id + "/hosts"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), HostMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetLocationHostsCall callGetLocationHosts()
    {
        return new GetLocationHostsCall(this);
    }



    public static class GetLocationCall extends BergamotAPICall<LocationMO>
    {

        private UUID id;

        public GetLocationCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetLocationCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public LocationMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/location/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), LocationMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetLocationCall callGetLocation()
    {
        return new GetLocationCall(this);
    }



    public static class GetGroupCall extends BergamotAPICall<GroupMO>
    {

        private UUID id;

        public GetGroupCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetGroupCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public GroupMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/group/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), GroupMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetGroupCall callGetGroup()
    {
        return new GetGroupCall(this);
    }



    public static class ExecuteChecksInGroupCall extends BergamotAPICall<String>
    {

        private UUID id;

        public ExecuteChecksInGroupCall(BaseBergamotClient client)
        {
            super(client);
        }


        public ExecuteChecksInGroupCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/group/id/" + this.id + "/execute-all-checks"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public ExecuteChecksInGroupCall callExecuteChecksInGroup()
    {
        return new ExecuteChecksInGroupCall(this);
    }



    public static class GetGroupsCall extends BergamotAPICall<List<GroupMO>>
    {

        public GetGroupsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<GroupMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/group/"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), GroupMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetGroupsCall callGetGroups()
    {
        return new GetGroupsCall(this);
    }



    public static class GetRootGroupsCall extends BergamotAPICall<List<GroupMO>>
    {

        public GetRootGroupsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<GroupMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/group/roots"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), GroupMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetRootGroupsCall callGetRootGroups()
    {
        return new GetRootGroupsCall(this);
    }



    public static class GetGroupByNameCall extends BergamotAPICall<GroupMO>
    {

        private String name;

        public GetGroupByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetGroupByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public GroupMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/group/name/" + this.name + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), GroupMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetGroupByNameCall callGetGroupByName()
    {
        return new GetGroupByNameCall(this);
    }



    public static class GetGroupChildrenCall extends BergamotAPICall<List<GroupMO>>
    {

        private UUID id;

        public GetGroupChildrenCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetGroupChildrenCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<GroupMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/group/id/" + this.id + "/children"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), GroupMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetGroupChildrenCall callGetGroupChildren()
    {
        return new GetGroupChildrenCall(this);
    }



    public static class GetGroupChecksCall extends BergamotAPICall<List<CheckMO>>
    {

        private UUID id;

        public GetGroupChecksCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetGroupChecksCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<CheckMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/group/id/" + this.id + "/checks"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), CheckMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetGroupChecksCall callGetGroupChecks()
    {
        return new GetGroupChecksCall(this);
    }



    public static class GetGroupChildrenByNameCall extends BergamotAPICall<List<GroupMO>>
    {

        private String name;

        public GetGroupChildrenByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetGroupChildrenByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public List<GroupMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/group/name/" + this.name + "/children"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), GroupMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetGroupChildrenByNameCall callGetGroupChildrenByName()
    {
        return new GetGroupChildrenByNameCall(this);
    }



    public static class GetGroupChecksByNameCall extends BergamotAPICall<List<CheckMO>>
    {

        private String name;

        public GetGroupChecksByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetGroupChecksByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public List<CheckMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/group/name/" + this.name + "/checks"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), CheckMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetGroupChecksByNameCall callGetGroupChecksByName()
    {
        return new GetGroupChecksByNameCall(this);
    }



    public static class GetClusterByNameCall extends BergamotAPICall<ClusterMO>
    {

        private String name;

        public GetClusterByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetClusterByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public ClusterMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/name/" + this.name + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), ClusterMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetClusterByNameCall callGetClusterByName()
    {
        return new GetClusterByNameCall(this);
    }



    public static class GetClusterCall extends BergamotAPICall<ClusterMO>
    {

        private UUID id;

        public GetClusterCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetClusterCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public ClusterMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), ClusterMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetClusterCall callGetCluster()
    {
        return new GetClusterCall(this);
    }



    public static class SuppressClusterCall extends BergamotAPICall<String>
    {

        private UUID id;

        public SuppressClusterCall(BaseBergamotClient client)
        {
            super(client);
        }


        public SuppressClusterCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/id/" + this.id + "/suppress"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public SuppressClusterCall callSuppressCluster()
    {
        return new SuppressClusterCall(this);
    }



    public static class UnsuppressClusterCall extends BergamotAPICall<String>
    {

        private UUID id;

        public UnsuppressClusterCall(BaseBergamotClient client)
        {
            super(client);
        }


        public UnsuppressClusterCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/id/" + this.id + "/unsuppress"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public UnsuppressClusterCall callUnsuppressCluster()
    {
        return new UnsuppressClusterCall(this);
    }



    public static class GetClustersCall extends BergamotAPICall<List<ClusterMO>>
    {

        public GetClustersCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<ClusterMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), ClusterMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetClustersCall callGetClusters()
    {
        return new GetClustersCall(this);
    }



    public static class GetClusterStateByNameCall extends BergamotAPICall<CheckStateMO>
    {

        private String name;

        public GetClusterStateByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetClusterStateByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public CheckStateMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/name/" + this.name + "/state"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CheckStateMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetClusterStateByNameCall callGetClusterStateByName()
    {
        return new GetClusterStateByNameCall(this);
    }



    public static class GetClusterStateCall extends BergamotAPICall<CheckStateMO>
    {

        private UUID id;

        public GetClusterStateCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetClusterStateCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public CheckStateMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/id/" + this.id + "/state"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CheckStateMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetClusterStateCall callGetClusterState()
    {
        return new GetClusterStateCall(this);
    }



    public static class GetClusterResourcesByNameCall extends BergamotAPICall<List<ResourceMO>>
    {

        private String name;

        public GetClusterResourcesByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetClusterResourcesByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public List<ResourceMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/name/" + this.name + "/resources"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), ResourceMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetClusterResourcesByNameCall callGetClusterResourcesByName()
    {
        return new GetClusterResourcesByNameCall(this);
    }



    public static class GetClusterResourcesCall extends BergamotAPICall<List<ResourceMO>>
    {

        private UUID id;

        public GetClusterResourcesCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetClusterResourcesCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<ResourceMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/id/" + this.id + "/resources"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), ResourceMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetClusterResourcesCall callGetClusterResources()
    {
        return new GetClusterResourcesCall(this);
    }



    public static class GetClusterReferencesByNameCall extends BergamotAPICall<List<CheckMO>>
    {

        private String name;

        public GetClusterReferencesByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetClusterReferencesByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public List<CheckMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/name/" + this.name + "/references"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), CheckMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetClusterReferencesByNameCall callGetClusterReferencesByName()
    {
        return new GetClusterReferencesByNameCall(this);
    }



    public static class GetClusterReferencesCall extends BergamotAPICall<List<CheckMO>>
    {

        private UUID id;

        public GetClusterReferencesCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetClusterReferencesCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<CheckMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/id/" + this.id + "/references"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), CheckMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetClusterReferencesCall callGetClusterReferences()
    {
        return new GetClusterReferencesCall(this);
    }



    public static class SuppressResourcesOnClusterCall extends BergamotAPICall<String>
    {

        private UUID id;

        public SuppressResourcesOnClusterCall(BaseBergamotClient client)
        {
            super(client);
        }


        public SuppressResourcesOnClusterCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/id/" + this.id + "/suppress-resources"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public SuppressResourcesOnClusterCall callSuppressResourcesOnCluster()
    {
        return new SuppressResourcesOnClusterCall(this);
    }



    public static class UnsuppressResourcesOnClusterCall extends BergamotAPICall<String>
    {

        private UUID id;

        public UnsuppressResourcesOnClusterCall(BaseBergamotClient client)
        {
            super(client);
        }


        public UnsuppressResourcesOnClusterCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/cluster/id/" + this.id + "/unsuppress-resources"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public UnsuppressResourcesOnClusterCall callUnsuppressResourcesOnCluster()
    {
        return new UnsuppressResourcesOnClusterCall(this);
    }



    public static class GetServiceCall extends BergamotAPICall<ServiceMO>
    {

        private UUID id;

        public GetServiceCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetServiceCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public ServiceMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/service/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), ServiceMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetServiceCall callGetService()
    {
        return new GetServiceCall(this);
    }



    public static class ExecuteServiceCall extends BergamotAPICall<String>
    {

        private UUID id;

        public ExecuteServiceCall(BaseBergamotClient client)
        {
            super(client);
        }


        public ExecuteServiceCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/service/id/" + this.id + "/execute"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public ExecuteServiceCall callExecuteService()
    {
        return new ExecuteServiceCall(this);
    }



    public static class SuppressServiceCall extends BergamotAPICall<String>
    {

        private UUID id;

        public SuppressServiceCall(BaseBergamotClient client)
        {
            super(client);
        }


        public SuppressServiceCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/service/id/" + this.id + "/suppress"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public SuppressServiceCall callSuppressService()
    {
        return new SuppressServiceCall(this);
    }



    public static class UnsuppressServiceCall extends BergamotAPICall<String>
    {

        private UUID id;

        public UnsuppressServiceCall(BaseBergamotClient client)
        {
            super(client);
        }


        public UnsuppressServiceCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/service/id/" + this.id + "/unsuppress"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public UnsuppressServiceCall callUnsuppressService()
    {
        return new UnsuppressServiceCall(this);
    }



    public static class GetServiceByNameCall extends BergamotAPICall<ServiceMO>
    {

        private String hostName;

        private String name;

        public GetServiceByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetServiceByNameCall hostName(String hostName)
        {
            this.hostName = hostName;
            return this;
        }

        public GetServiceByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public ServiceMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/service/name/" + this.hostName + "/" + this.name + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), ServiceMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetServiceByNameCall callGetServiceByName()
    {
        return new GetServiceByNameCall(this);
    }



    public static class GetServiceStateCall extends BergamotAPICall<CheckStateMO>
    {

        private UUID id;

        public GetServiceStateCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetServiceStateCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public CheckStateMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/service/id/" + this.id + "/state"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CheckStateMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetServiceStateCall callGetServiceState()
    {
        return new GetServiceStateCall(this);
    }



    public static class GetServiceStateByNameCall extends BergamotAPICall<CheckStateMO>
    {

        private String hostName;

        private String name;

        public GetServiceStateByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetServiceStateByNameCall hostName(String hostName)
        {
            this.hostName = hostName;
            return this;
        }

        public GetServiceStateByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public CheckStateMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/service/name/" + this.hostName + "/" + this.name + "/state"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CheckStateMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetServiceStateByNameCall callGetServiceStateByName()
    {
        return new GetServiceStateByNameCall(this);
    }



    public static class GetTrapCall extends BergamotAPICall<TrapMO>
    {

        private UUID id;

        public GetTrapCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTrapCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public TrapMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/trap/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), TrapMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTrapCall callGetTrap()
    {
        return new GetTrapCall(this);
    }



    public static class SuppressTrapCall extends BergamotAPICall<String>
    {

        private UUID id;

        public SuppressTrapCall(BaseBergamotClient client)
        {
            super(client);
        }


        public SuppressTrapCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/trap/id/" + this.id + "/suppress"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public SuppressTrapCall callSuppressTrap()
    {
        return new SuppressTrapCall(this);
    }



    public static class UnsuppressTrapCall extends BergamotAPICall<String>
    {

        private UUID id;

        public UnsuppressTrapCall(BaseBergamotClient client)
        {
            super(client);
        }


        public UnsuppressTrapCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/trap/id/" + this.id + "/unsuppress"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public UnsuppressTrapCall callUnsuppressTrap()
    {
        return new UnsuppressTrapCall(this);
    }



    public static class GetTrapByNameCall extends BergamotAPICall<TrapMO>
    {

        private String hostName;

        private String name;

        public GetTrapByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTrapByNameCall hostName(String hostName)
        {
            this.hostName = hostName;
            return this;
        }

        public GetTrapByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public TrapMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/trap/name/" + this.hostName + "/" + this.name + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), TrapMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTrapByNameCall callGetTrapByName()
    {
        return new GetTrapByNameCall(this);
    }



    public static class GetTrapStateCall extends BergamotAPICall<CheckStateMO>
    {

        private UUID id;

        public GetTrapStateCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTrapStateCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public CheckStateMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/trap/id/" + this.id + "/state"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CheckStateMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTrapStateCall callGetTrapState()
    {
        return new GetTrapStateCall(this);
    }



    public static class GetTrapStateByNameCall extends BergamotAPICall<CheckStateMO>
    {

        private String hostName;

        private String name;

        public GetTrapStateByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTrapStateByNameCall hostName(String hostName)
        {
            this.hostName = hostName;
            return this;
        }

        public GetTrapStateByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public CheckStateMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/trap/name/" + this.hostName + "/" + this.name + "/state"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CheckStateMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTrapStateByNameCall callGetTrapStateByName()
    {
        return new GetTrapStateByNameCall(this);
    }



    public static class SubmitTrapStatusCall extends BergamotAPICall<String>
    {

        private UUID id;

        private String status;

        private String output;

        public SubmitTrapStatusCall(BaseBergamotClient client)
        {
            super(client);
        }


        public SubmitTrapStatusCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public SubmitTrapStatusCall status(String status)
        {
            this.status = status;
            return this;
        }

        public SubmitTrapStatusCall output(String output)
        {
            this.output = output;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/trap/id/" + this.id + "/submit"))
                    .addHeader(authHeader())
                    .bodyForm(
                        param("status", this.status),
                        param("output", this.output)
                    )
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public SubmitTrapStatusCall callSubmitTrapStatus()
    {
        return new SubmitTrapStatusCall(this);
    }



    public static class SuppressResourceCall extends BergamotAPICall<String>
    {

        private UUID id;

        public SuppressResourceCall(BaseBergamotClient client)
        {
            super(client);
        }


        public SuppressResourceCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/resource/id/" + this.id + "/suppress"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public SuppressResourceCall callSuppressResource()
    {
        return new SuppressResourceCall(this);
    }



    public static class UnsuppressResourceCall extends BergamotAPICall<String>
    {

        private UUID id;

        public UnsuppressResourceCall(BaseBergamotClient client)
        {
            super(client);
        }


        public UnsuppressResourceCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/resource/id/" + this.id + "/unsuppress"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public UnsuppressResourceCall callUnsuppressResource()
    {
        return new UnsuppressResourceCall(this);
    }



    public static class GetResourceByNameCall extends BergamotAPICall<ResourceMO>
    {

        private String clusterName;

        private String name;

        public GetResourceByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetResourceByNameCall clusterName(String clusterName)
        {
            this.clusterName = clusterName;
            return this;
        }

        public GetResourceByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public ResourceMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/resource/name/" + this.clusterName + "/" + this.name + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), ResourceMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetResourceByNameCall callGetResourceByName()
    {
        return new GetResourceByNameCall(this);
    }



    public static class GetResourceStateCall extends BergamotAPICall<CheckStateMO>
    {

        private UUID id;

        public GetResourceStateCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetResourceStateCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public CheckStateMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/resource/id/" + this.id + "/state"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CheckStateMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetResourceStateCall callGetResourceState()
    {
        return new GetResourceStateCall(this);
    }



    public static class GetResourceStateByNameCall extends BergamotAPICall<CheckStateMO>
    {

        private String clusterName;

        private String name;

        public GetResourceStateByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetResourceStateByNameCall clusterName(String clusterName)
        {
            this.clusterName = clusterName;
            return this;
        }

        public GetResourceStateByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public CheckStateMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/resource/name/" + this.clusterName + "/" + this.name + "/state"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CheckStateMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetResourceStateByNameCall callGetResourceStateByName()
    {
        return new GetResourceStateByNameCall(this);
    }



    public static class GetResourceCall extends BergamotAPICall<ResourceMO>
    {

        private UUID id;

        public GetResourceCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetResourceCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public ResourceMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/resource/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), ResourceMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetResourceCall callGetResource()
    {
        return new GetResourceCall(this);
    }



    public static class GetTimePeriodCall extends BergamotAPICall<TimePeriodMO>
    {

        private UUID id;

        public GetTimePeriodCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTimePeriodCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public TimePeriodMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/time-period/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), TimePeriodMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTimePeriodCall callGetTimePeriod()
    {
        return new GetTimePeriodCall(this);
    }



    public static class GetTimePeriodsCall extends BergamotAPICall<List<TimePeriodMO>>
    {

        public GetTimePeriodsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<TimePeriodMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/time-period/"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), TimePeriodMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTimePeriodsCall callGetTimePeriods()
    {
        return new GetTimePeriodsCall(this);
    }



    public static class GetTimePeriodByNameCall extends BergamotAPICall<TimePeriodMO>
    {

        private String name;

        public GetTimePeriodByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTimePeriodByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public TimePeriodMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/time-period/name/" + this.name + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), TimePeriodMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTimePeriodByNameCall callGetTimePeriodByName()
    {
        return new GetTimePeriodByNameCall(this);
    }



    public static class GetCommandCall extends BergamotAPICall<CommandMO>
    {

        private UUID id;

        public GetCommandCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetCommandCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public CommandMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/command/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CommandMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetCommandCall callGetCommand()
    {
        return new GetCommandCall(this);
    }



    public static class GetCommandsCall extends BergamotAPICall<List<CommandMO>>
    {

        public GetCommandsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<CommandMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/command/"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), CommandMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetCommandsCall callGetCommands()
    {
        return new GetCommandsCall(this);
    }



    public static class GetCommandByNameCall extends BergamotAPICall<CommandMO>
    {

        private String name;

        public GetCommandByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetCommandByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public CommandMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/command/name/" + this.name + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CommandMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetCommandByNameCall callGetCommandByName()
    {
        return new GetCommandByNameCall(this);
    }



    public static class GetContactByNameOrEmailCall extends BergamotAPICall<ContactMO>
    {

        private String nameOrEmail;

        public GetContactByNameOrEmailCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetContactByNameOrEmailCall nameOrEmail(String nameOrEmail)
        {
            this.nameOrEmail = nameOrEmail;
            return this;
        }

        public ContactMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/contact/name-or-email/" + this.nameOrEmail + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), ContactMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetContactByNameOrEmailCall callGetContactByNameOrEmail()
    {
        return new GetContactByNameOrEmailCall(this);
    }



    public static class GetContactCall extends BergamotAPICall<ContactMO>
    {

        private UUID id;

        public GetContactCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetContactCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public ContactMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/contact/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), ContactMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetContactCall callGetContact()
    {
        return new GetContactCall(this);
    }



    public static class GetContactsCall extends BergamotAPICall<List<ContactMO>>
    {

        public GetContactsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<ContactMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/contact/"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), ContactMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetContactsCall callGetContacts()
    {
        return new GetContactsCall(this);
    }



    public static class GetContactByNameCall extends BergamotAPICall<ContactMO>
    {

        private String name;

        public GetContactByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetContactByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public ContactMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/contact/name/" + this.name + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), ContactMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetContactByNameCall callGetContactByName()
    {
        return new GetContactByNameCall(this);
    }



    public static class GetContactByEmailCall extends BergamotAPICall<ContactMO>
    {

        private String email;

        public GetContactByEmailCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetContactByEmailCall email(String email)
        {
            this.email = email;
            return this;
        }

        public ContactMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/contact/email/" + this.email + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), ContactMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetContactByEmailCall callGetContactByEmail()
    {
        return new GetContactByEmailCall(this);
    }



    public static class GetTeamCall extends BergamotAPICall<TeamMO>
    {

        private UUID id;

        public GetTeamCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTeamCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public TeamMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/team/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), TeamMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTeamCall callGetTeam()
    {
        return new GetTeamCall(this);
    }



    public static class GetTeamsCall extends BergamotAPICall<List<TeamMO>>
    {

        public GetTeamsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<TeamMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/team/"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), TeamMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTeamsCall callGetTeams()
    {
        return new GetTeamsCall(this);
    }



    public static class GetTeamByNameCall extends BergamotAPICall<TeamMO>
    {

        private String name;

        public GetTeamByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTeamByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public TeamMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/team/name/" + this.name + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), TeamMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTeamByNameCall callGetTeamByName()
    {
        return new GetTeamByNameCall(this);
    }



    public static class GetTeamChildrenByNameCall extends BergamotAPICall<List<TeamMO>>
    {

        private String name;

        public GetTeamChildrenByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTeamChildrenByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public List<TeamMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/team/name/" + this.name + "/children"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), TeamMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTeamChildrenByNameCall callGetTeamChildrenByName()
    {
        return new GetTeamChildrenByNameCall(this);
    }



    public static class GetTeamContactsByNameCall extends BergamotAPICall<List<ContactMO>>
    {

        private String name;

        public GetTeamContactsByNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTeamContactsByNameCall name(String name)
        {
            this.name = name;
            return this;
        }

        public List<ContactMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/team/name/" + this.name + "/contacts"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), ContactMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTeamContactsByNameCall callGetTeamContactsByName()
    {
        return new GetTeamContactsByNameCall(this);
    }



    public static class GetTeamChildrenCall extends BergamotAPICall<List<TeamMO>>
    {

        private UUID id;

        public GetTeamChildrenCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTeamChildrenCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<TeamMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/team/id/" + this.id + "/children"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), TeamMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTeamChildrenCall callGetTeamChildren()
    {
        return new GetTeamChildrenCall(this);
    }



    public static class GetTeamContactsCall extends BergamotAPICall<List<ContactMO>>
    {

        private UUID id;

        public GetTeamContactsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetTeamContactsCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<ContactMO> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/team/id/" + this.id + "/contacts"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), ContactMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetTeamContactsCall callGetTeamContacts()
    {
        return new GetTeamContactsCall(this);
    }



    public static class GetCommentCall extends BergamotAPICall<CommentMO>
    {

        private UUID id;

        public GetCommentCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetCommentCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public CommentMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/comment/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CommentMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetCommentCall callGetComment()
    {
        return new GetCommentCall(this);
    }



    public static class RemoveCommentCall extends BergamotAPICall<Boolean>
    {

        private UUID id;

        public RemoveCommentCall(BaseBergamotClient client)
        {
            super(client);
        }


        public RemoveCommentCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public Boolean execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/comment/id/" + this.id + "/remove"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), Boolean.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public RemoveCommentCall callRemoveComment()
    {
        return new RemoveCommentCall(this);
    }



    public static class GetCommentsForObjectCall extends BergamotAPICall<List<CommentMO>>
    {

        private UUID id;

        private Long offset;

        private Long limit;

        public GetCommentsForObjectCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetCommentsForObjectCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public GetCommentsForObjectCall offset(Long offset)
        {
            this.offset = offset;
            return this;
        }

        public GetCommentsForObjectCall limit(Long limit)
        {
            this.limit = limit;
            return this;
        }

        public List<CommentMO> execute()
        {
            try
            {
                Response response = execute(
                    get(
                        appendQuery(
                            url("/api/comment/for-object/id/" + this.id + ""),
                        param("offset", this.offset),
                        param("limit", this.limit)
                        )
                    ).addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), CommentMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetCommentsForObjectCall callGetCommentsForObject()
    {
        return new GetCommentsForObjectCall(this);
    }



    public static class AddCommentToCheckCall extends BergamotAPICall<CommentMO>
    {

        private UUID id;

        private String summary;

        private String message;

        public AddCommentToCheckCall(BaseBergamotClient client)
        {
            super(client);
        }


        public AddCommentToCheckCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public AddCommentToCheckCall summary(String summary)
        {
            this.summary = summary;
            return this;
        }

        public AddCommentToCheckCall message(String message)
        {
            this.message = message;
            return this;
        }

        public CommentMO execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/comment/add-comment-to-check/id/" + this.id + ""))
                    .addHeader(authHeader())
                    .bodyForm(
                        param("summary", this.summary),
                        param("comment", this.message)
                    )
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CommentMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public AddCommentToCheckCall callAddCommentToCheck()
    {
        return new AddCommentToCheckCall(this);
    }



    public static class AddCommentToAlertCall extends BergamotAPICall<CommentMO>
    {

        private UUID id;

        private String summary;

        private String message;

        public AddCommentToAlertCall(BaseBergamotClient client)
        {
            super(client);
        }


        public AddCommentToAlertCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public AddCommentToAlertCall summary(String summary)
        {
            this.summary = summary;
            return this;
        }

        public AddCommentToAlertCall message(String message)
        {
            this.message = message;
            return this;
        }

        public CommentMO execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/comment/add-comment-to-alert/id/" + this.id + ""))
                    .addHeader(authHeader())
                    .bodyForm(
                        param("summary", this.summary),
                        param("comment", this.message)
                    )
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CommentMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public AddCommentToAlertCall callAddCommentToAlert()
    {
        return new AddCommentToAlertCall(this);
    }



    public static class AddCommentToDowntimeCall extends BergamotAPICall<CommentMO>
    {

        private UUID id;

        private String summary;

        private String message;

        public AddCommentToDowntimeCall(BaseBergamotClient client)
        {
            super(client);
        }


        public AddCommentToDowntimeCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public AddCommentToDowntimeCall summary(String summary)
        {
            this.summary = summary;
            return this;
        }

        public AddCommentToDowntimeCall message(String message)
        {
            this.message = message;
            return this;
        }

        public CommentMO execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/comment/add-comment-to-downtime/id/" + this.id + ""))
                    .addHeader(authHeader())
                    .bodyForm(
                        param("summary", this.summary),
                        param("comment", this.message)
                    )
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CommentMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public AddCommentToDowntimeCall callAddCommentToDowntime()
    {
        return new AddCommentToDowntimeCall(this);
    }



    public static class AddCommentToObjectCall extends BergamotAPICall<CommentMO>
    {

        private UUID id;

        private String summary;

        private String message;

        public AddCommentToObjectCall(BaseBergamotClient client)
        {
            super(client);
        }


        public AddCommentToObjectCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public AddCommentToObjectCall summary(String summary)
        {
            this.summary = summary;
            return this;
        }

        public AddCommentToObjectCall message(String message)
        {
            this.message = message;
            return this;
        }

        public CommentMO execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/comment/add-comment-to-object/id/" + this.id + ""))
                    .addHeader(authHeader())
                    .bodyForm(
                        param("summary", this.summary),
                        param("comment", this.message)
                    )
                );
                return transcoder().decodeFromString(response.returnContent().asString(), CommentMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public AddCommentToObjectCall callAddCommentToObject()
    {
        return new AddCommentToObjectCall(this);
    }



    public static class GetDowntimeCall extends BergamotAPICall<DowntimeMO>
    {

        private UUID id;

        public GetDowntimeCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetDowntimeCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public DowntimeMO execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/downtime/id/" + this.id + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), DowntimeMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetDowntimeCall callGetDowntime()
    {
        return new GetDowntimeCall(this);
    }



    public static class RemoveDowntimeCall extends BergamotAPICall<Boolean>
    {

        private UUID id;

        public RemoveDowntimeCall(BaseBergamotClient client)
        {
            super(client);
        }


        public RemoveDowntimeCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public Boolean execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/downtime/id/" + this.id + "/remove"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), Boolean.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public RemoveDowntimeCall callRemoveDowntime()
    {
        return new RemoveDowntimeCall(this);
    }



    public static class GetDowntimeForObjectCall extends BergamotAPICall<List<DowntimeMO>>
    {

        private UUID id;

        private Integer pastDays;

        private Integer futureDays;

        public GetDowntimeForObjectCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetDowntimeForObjectCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public GetDowntimeForObjectCall pastDays(Integer pastDays)
        {
            this.pastDays = pastDays;
            return this;
        }

        public GetDowntimeForObjectCall futureDays(Integer futureDays)
        {
            this.futureDays = futureDays;
            return this;
        }

        public List<DowntimeMO> execute()
        {
            try
            {
                Response response = execute(
                    get(
                        appendQuery(
                            url("/api/downtime/for-object/id/" + this.id + ""),
                        param("past", this.pastDays),
                        param("future", this.futureDays)
                        )
                    ).addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), DowntimeMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetDowntimeForObjectCall callGetDowntimeForObject()
    {
        return new GetDowntimeForObjectCall(this);
    }



    public static class AddDowntimeToCheckCall extends BergamotAPICall<DowntimeMO>
    {

        private UUID id;

        private Date startTime;

        private Date endTime;

        private String summary;

        private String description;

        public AddDowntimeToCheckCall(BaseBergamotClient client)
        {
            super(client);
        }


        public AddDowntimeToCheckCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public AddDowntimeToCheckCall startTime(Date startTime)
        {
            this.startTime = startTime;
            return this;
        }

        public AddDowntimeToCheckCall endTime(Date endTime)
        {
            this.endTime = endTime;
            return this;
        }

        public AddDowntimeToCheckCall summary(String summary)
        {
            this.summary = summary;
            return this;
        }

        public AddDowntimeToCheckCall description(String description)
        {
            this.description = description;
            return this;
        }

        public DowntimeMO execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/downtime/add-downtime-to-check/id/" + this.id + ""))
                    .addHeader(authHeader())
                    .bodyForm(
                        param("starts", this.startTime),
                        param("ends", this.endTime),
                        param("summary", this.summary),
                        param("description", this.description)
                    )
                );
                return transcoder().decodeFromString(response.returnContent().asString(), DowntimeMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public AddDowntimeToCheckCall callAddDowntimeToCheck()
    {
        return new AddDowntimeToCheckCall(this);
    }



    public static class ObjectExistsCall extends BergamotAPICall<Boolean>
    {

        private String type;

        private String name;

        public ObjectExistsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public ObjectExistsCall type(String type)
        {
            this.type = type;
            return this;
        }

        public ObjectExistsCall name(String name)
        {
            this.name = name;
            return this;
        }

        public Boolean execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/config/exists/" + this.type + "/" + this.name + ""))
                    .addHeader(authHeader())
                    .bodyForm(

                    )
                );
                return transcoder().decodeFromString(response.returnContent().asString(), Boolean.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public ObjectExistsCall callObjectExists()
    {
        return new ObjectExistsCall(this);
    }



    public static class ListIconsCall extends BergamotAPICall<List<String>>
    {

        public ListIconsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public List<String> execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/config/icon/"))
                    .addHeader(authHeader())
                    .bodyForm(

                    )
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public ListIconsCall callListIcons()
    {
        return new ListIconsCall(this);
    }



    public static class GetCheckTransitionsCall extends BergamotAPICall<List<CheckTransitionMO>>
    {

        private UUID id;

        private Long offset;

        private Long limit;

        public GetCheckTransitionsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetCheckTransitionsCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public GetCheckTransitionsCall offset(Long offset)
        {
            this.offset = offset;
            return this;
        }

        public GetCheckTransitionsCall limit(Long limit)
        {
            this.limit = limit;
            return this;
        }

        public List<CheckTransitionMO> execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/stats/transitions/check/id/" + this.id + ""))
                    .addHeader(authHeader())
                    .bodyForm(
                        param("offset", this.offset),
                        param("limit", this.limit)
                    )
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), CheckTransitionMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetCheckTransitionsCall callGetCheckTransitions()
    {
        return new GetCheckTransitionsCall(this);
    }



    public static class VersionNumberCall extends BergamotAPICall<String>
    {

        public VersionNumberCall(BaseBergamotClient client)
        {
            super(client);
        }


        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/util/version/number"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public VersionNumberCall callVersionNumber()
    {
        return new VersionNumberCall(this);
    }



    public static class VersionCodeNameCall extends BergamotAPICall<String>
    {

        public VersionCodeNameCall(BaseBergamotClient client)
        {
            super(client);
        }


        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/util/version/codename"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public VersionCodeNameCall callVersionCodeName()
    {
        return new VersionCodeNameCall(this);
    }



    public static class NewIdCall extends BergamotAPICall<UUID>
    {

        public NewIdCall(BaseBergamotClient client)
        {
            super(client);
        }


        public UUID execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/util/id/new"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), UUID.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public NewIdCall callNewId()
    {
        return new NewIdCall(this);
    }



    public static class NewIdsCall extends BergamotAPICall<List<UUID>>
    {

        private Integer count;

        public NewIdsCall(BaseBergamotClient client)
        {
            super(client);
        }


        public NewIdsCall count(Integer count)
        {
            this.count = count;
            return this;
        }

        public List<UUID> execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/util/id/new/" + this.count + ""))
                    .addHeader(authHeader())
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), UUID.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public NewIdsCall callNewIds()
    {
        return new NewIdsCall(this);
    }



    public static class VersionCall extends BergamotAPICall<String>
    {

        public VersionCall(BaseBergamotClient client)
        {
            super(client);
        }


        public String execute()
        {
            try
            {
                Response response = execute(
                    get(url("/api/util/version"))
                    .addHeader(authHeader())
                );
                return transcoder().decodeFromString(response.returnContent().asString(), String.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public VersionCall callVersion()
    {
        return new VersionCall(this);
    }



    public static class GetReadingsByCheckCall extends BergamotAPICall<List<CheckReadingMO>>
    {

        private UUID id;

        public GetReadingsByCheckCall(BaseBergamotClient client)
        {
            super(client);
        }


        public GetReadingsByCheckCall id(UUID id)
        {
            this.id = id;
            return this;
        }

        public List<CheckReadingMO> execute()
        {
            try
            {
                Response response = execute(
                    post(url("/api/lamplighter/check/id/" + this.id + "/readings"))
                    .addHeader(authHeader())
                    .bodyForm(

                    )
                );
                return transcoder().decodeListFromString(response.returnContent().asString(), CheckReadingMO.class);
            }
            catch (IOException e)
            {
                throw new BergamotAPIException("Error calling Bergamot Monitoring API", e);
            }
        }

    }


    public GetReadingsByCheckCall callGetReadingsByCheck()
    {
        return new GetReadingsByCheckCall(this);
    }

}