func (serviceroot *Service) DeleteSession(url string) error {
	return redfish.DeleteSession(serviceroot.Client, url)
}
DeleteSession logout the specified session
package gofish
import (
	"encoding/json"
	"github.com/stmcginnis/gofish/common"
	"github.com/stmcginnis/gofish/redfish"
	"github.com/stmcginnis/gofish/swordfish"
)
type Expand struct {
	ExpandAll bool
	Levels bool
	Links bool
	MaxLevels int
	NoLinks bool
}
type ProtocolFeaturesSupported struct {
	ExcerptQuery bool
	ExpandQuery Expand
	FilterQuery bool
	OnlyMemberQuery bool
	SelectQuery bool
}
type Service struct {
	common.Entity
	ODataContext string `json:"@odata.context"`
	ODataID string `json:"@odata.id"`
	ODataType string `json:"@odata.type"`
	accountService string
	certificateService string
	chassis string
	compositionService string
	Description string
	eventService string
	fabrics string
	jobService string
	jsonSchemas string
	managers string
	Oem json.RawMessage
	Product string
	ProtocolFeaturesSupported ProtocolFeaturesSupported
	RedfishVersion string
	registries string
	resourceBlocks string
	sessionService string
	storageServices string
	storageSystems string
	systems string
	tasks string
	telemetryService string
	UUID string
	updateService string
	Vendor string
	sessions string
}
func (serviceroot *Service) UnmarshalJSON(b []byte) error {
	type temp Service
	var t struct {
		temp
		CertificateService common.Link
		Chassis            common.Link
		Managers           common.Link
		Tasks              common.Link
		StorageServices    common.Link
		StorageSystems     common.Link
		AccountService     common.Link
		EventService       common.Link
		Registries         common.Link
		Systems            common.Link
		CompositionService common.Link
		Fabrics            common.Link
		JobService         common.Link
		JSONSchemas        common.Link `json:"JsonSchemas"`
		ResourceBlocks     common.Link
		SessionService     common.Link
		TelemetryService   common.Link
		UpdateService      common.Link
		Links              struct {
			Sessions common.Link
		}
		Oem json.RawMessage  
	}
	err := json.Unmarshal(b, &t)
	if err != nil {
		return err
	}
	*serviceroot = Service(t.temp)
	serviceroot.certificateService = string(t.CertificateService)
	serviceroot.chassis = string(t.Chassis)
	serviceroot.managers = string(t.Managers)
	serviceroot.tasks = string(t.Tasks)
	serviceroot.sessions = string(t.Links.Sessions)
	serviceroot.storageServices = string(t.StorageServices)
	serviceroot.storageSystems = string(t.StorageSystems)
	serviceroot.accountService = string(t.AccountService)
	serviceroot.eventService = string(t.EventService)
	serviceroot.registries = string(t.Registries)
	serviceroot.systems = string(t.Systems)
	serviceroot.compositionService = string(t.CompositionService)
	serviceroot.fabrics = string(t.Fabrics)
	serviceroot.jobService = string(t.JobService)
	serviceroot.jsonSchemas = string(t.JSONSchemas)
	serviceroot.resourceBlocks = string(t.ResourceBlocks)
	serviceroot.sessionService = string(t.SessionService)
	serviceroot.telemetryService = string(t.TelemetryService)
	serviceroot.updateService = string(t.UpdateService)
	serviceroot.Oem = t.Oem
	return nil
}
func ServiceRoot(c common.Client) (*Service, error) {
	resp, err := c.Get(common.DefaultServiceRoot)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	var serviceroot Service
	err = json.NewDecoder(resp.Body).Decode(&serviceroot)
	if err != nil {
		return nil, err
	}
	serviceroot.SetClient(c)
	return &serviceroot, nil
}
func (serviceroot *Service) Chassis() ([]*redfish.Chassis, error) {
	return redfish.ListReferencedChassis(serviceroot.Client, serviceroot.chassis)
}
func (serviceroot *Service) Managers() ([]*redfish.Manager, error) {
	return redfish.ListReferencedManagers(serviceroot.Client, serviceroot.managers)
}
func (serviceroot *Service) StorageSystems() ([]*swordfish.StorageSystem, error) {
	return swordfish.ListReferencedStorageSystems(serviceroot.Client, serviceroot.storageSystems)
}
func (serviceroot *Service) StorageServices() ([]*swordfish.StorageService, error) {
	return swordfish.ListReferencedStorageServices(serviceroot.Client, serviceroot.storageServices)
}
func (serviceroot *Service) Tasks() ([]*redfish.Task, error) {
	return redfish.ListReferencedTasks(serviceroot.Client, serviceroot.tasks)
}
func (serviceroot *Service) CreateSession(username, password string) (*redfish.AuthToken, error) {
	return redfish.CreateSession(serviceroot.Client, serviceroot.sessions, username, password)
}
func (serviceroot *Service) Sessions() ([]*redfish.Session, error) {
	return redfish.ListReferencedSessions(serviceroot.Client, serviceroot.sessions)
}