// Code generated by ./crud.sh -o crud.go; DO NOT EDIT.

package icinga

import "fmt"

// Hosts returns a slice of Host matching the filter expression filter.
// If no hosts match, error wraps ErrNoMatch.
// To fetch all host, set filter to the empty string ("").
func (c *Client) Hosts(filter string) ([]Host, error) {
	objects, err := c.filterObjects("/objects/hosts", filter)
	if err != nil {
		return nil, fmt.Errorf("get hosts filter %s: %w", filter, err)
	}
	var hosts []Host
	for _, o := range objects {
		v, ok := o.(Host)
		if !ok {
			return nil, fmt.Errorf("get hosts filter %s: %T in response", filter, v)
		}
		hosts = append(hosts, v)
	}
	return hosts, nil
}

// LookupHost returns the Host identified by name. If no Host is found, error
// wraps ErrNotExist.
func (c *Client) LookupHost(name string) (Host, error) {
	obj, err := c.lookupObject("/objects/hosts/" + name)
	if err != nil {
		return Host{}, fmt.Errorf("lookup host %s: %w", name, err)
	}
	v, ok := obj.(Host)
	if !ok {
		return Host{}, fmt.Errorf("lookup host %s: result type %T is not Host", name, v)
	}
	return v, nil
}

// CreateHost creates host. Some fields of host must be set for successful
// creation; see the type definition of Host for details.
func (c *Client) CreateHost(host Host) error {
	if err := c.createObject(host); err != nil {
		return fmt.Errorf("create host %s: %w", host.Name, err)
	}
	return nil
}

// DeleteHost deletes the Host identified by name. If cascade is true, objects
// depending on the Host are also deleted. If no Host is found, error wraps
// ErrNotExist.
func (c *Client) DeleteHost(name string, cascade bool) error {
	if err := c.deleteObject("/objects/hosts/"+name, cascade); err != nil {
		return fmt.Errorf("delete host %s: %w", name, err)
	}
	return nil
}
// Services returns a slice of Service matching the filter expression filter.
// If no services match, error wraps ErrNoMatch.
// To fetch all service, set filter to the empty string ("").
func (c *Client) Services(filter string) ([]Service, error) {
	objects, err := c.filterObjects("/objects/services", filter)
	if err != nil {
		return nil, fmt.Errorf("get services filter %s: %w", filter, err)
	}
	var services []Service
	for _, o := range objects {
		v, ok := o.(Service)
		if !ok {
			return nil, fmt.Errorf("get services filter %s: %T in response", filter, v)
		}
		services = append(services, v)
	}
	return services, nil
}

// LookupService returns the Service identified by name. If no Service is found, error
// wraps ErrNotExist.
func (c *Client) LookupService(name string) (Service, error) {
	obj, err := c.lookupObject("/objects/services/" + name)
	if err != nil {
		return Service{}, fmt.Errorf("lookup service %s: %w", name, err)
	}
	v, ok := obj.(Service)
	if !ok {
		return Service{}, fmt.Errorf("lookup service %s: result type %T is not Service", name, v)
	}
	return v, nil
}

// CreateService creates service. Some fields of service must be set for successful
// creation; see the type definition of Service for details.
func (c *Client) CreateService(service Service) error {
	if err := c.createObject(service); err != nil {
		return fmt.Errorf("create service %s: %w", service.Name, err)
	}
	return nil
}

// DeleteService deletes the Service identified by name. If cascade is true, objects
// depending on the Service are also deleted. If no Service is found, error wraps
// ErrNotExist.
func (c *Client) DeleteService(name string, cascade bool) error {
	if err := c.deleteObject("/objects/services/"+name, cascade); err != nil {
		return fmt.Errorf("delete service %s: %w", name, err)
	}
	return nil
}
// Users returns a slice of User matching the filter expression filter.
// If no users match, error wraps ErrNoMatch.
// To fetch all user, set filter to the empty string ("").
func (c *Client) Users(filter string) ([]User, error) {
	objects, err := c.filterObjects("/objects/users", filter)
	if err != nil {
		return nil, fmt.Errorf("get users filter %s: %w", filter, err)
	}
	var users []User
	for _, o := range objects {
		v, ok := o.(User)
		if !ok {
			return nil, fmt.Errorf("get users filter %s: %T in response", filter, v)
		}
		users = append(users, v)
	}
	return users, nil
}

// LookupUser returns the User identified by name. If no User is found, error
// wraps ErrNotExist.
func (c *Client) LookupUser(name string) (User, error) {
	obj, err := c.lookupObject("/objects/users/" + name)
	if err != nil {
		return User{}, fmt.Errorf("lookup user %s: %w", name, err)
	}
	v, ok := obj.(User)
	if !ok {
		return User{}, fmt.Errorf("lookup user %s: result type %T is not User", name, v)
	}
	return v, nil
}

// CreateUser creates user. Some fields of user must be set for successful
// creation; see the type definition of User for details.
func (c *Client) CreateUser(user User) error {
	if err := c.createObject(user); err != nil {
		return fmt.Errorf("create user %s: %w", user.Name, err)
	}
	return nil
}

// DeleteUser deletes the User identified by name. If cascade is true, objects
// depending on the User are also deleted. If no User is found, error wraps
// ErrNotExist.
func (c *Client) DeleteUser(name string, cascade bool) error {
	if err := c.deleteObject("/objects/users/"+name, cascade); err != nil {
		return fmt.Errorf("delete user %s: %w", name, err)
	}
	return nil
}
// HostGroups returns a slice of HostGroup matching the filter expression filter.
// If no hostgroups match, error wraps ErrNoMatch.
// To fetch all hostgroup, set filter to the empty string ("").
func (c *Client) HostGroups(filter string) ([]HostGroup, error) {
	objects, err := c.filterObjects("/objects/hostgroups", filter)
	if err != nil {
		return nil, fmt.Errorf("get hostgroups filter %s: %w", filter, err)
	}
	var hostgroups []HostGroup
	for _, o := range objects {
		v, ok := o.(HostGroup)
		if !ok {
			return nil, fmt.Errorf("get hostgroups filter %s: %T in response", filter, v)
		}
		hostgroups = append(hostgroups, v)
	}
	return hostgroups, nil
}

// LookupHostGroup returns the HostGroup identified by name. If no HostGroup is found, error
// wraps ErrNotExist.
func (c *Client) LookupHostGroup(name string) (HostGroup, error) {
	obj, err := c.lookupObject("/objects/hostgroups/" + name)
	if err != nil {
		return HostGroup{}, fmt.Errorf("lookup hostgroup %s: %w", name, err)
	}
	v, ok := obj.(HostGroup)
	if !ok {
		return HostGroup{}, fmt.Errorf("lookup hostgroup %s: result type %T is not HostGroup", name, v)
	}
	return v, nil
}

// CreateHostGroup creates hostgroup. Some fields of hostgroup must be set for successful
// creation; see the type definition of HostGroup for details.
func (c *Client) CreateHostGroup(hostgroup HostGroup) error {
	if err := c.createObject(hostgroup); err != nil {
		return fmt.Errorf("create hostgroup %s: %w", hostgroup.Name, err)
	}
	return nil
}

// DeleteHostGroup deletes the HostGroup identified by name. If cascade is true, objects
// depending on the HostGroup are also deleted. If no HostGroup is found, error wraps
// ErrNotExist.
func (c *Client) DeleteHostGroup(name string, cascade bool) error {
	if err := c.deleteObject("/objects/hostgroups/"+name, cascade); err != nil {
		return fmt.Errorf("delete hostgroup %s: %w", name, err)
	}
	return nil
}