(data, &outErr)
		return nil, fmt.Errorf("Error in response: %s", outErr.Err)
	}
	if err!= nil {
		return nil, err
	}

	return data, nil
}

func (c *Client) SSHKey() *sshKey {
	return &sshKey{c}
}

func (c *sshKey) namespace() string {
	return "SoftLayer_Security_Ssh_Key"
}

func (c *sshKey) Create(label, key string) (*SSHKey, error) {
	var (
		method = "POST"
		uri    = c.namespace()
		body   = SSHKey{Key: key, Label: label}
	)

	data, err := c.newRequest(method, uri, map[string]interface{}{"parameters": []interface{}{body}})
	if err!= nil {
		return nil, err
	}

	var k SSHKey
	if err := json.Unmarshal(data, &k); err!= nil {
		return nil, err
	}

	return &k, nil
}

func (c *sshKey) Delete(id int) error {
	var (
		method = "DELETE"
		uri    = fmt.Sprintf("%s/%v", c.namespace(), id)
	)

	_, err := c.newRequest(method, uri, nil)
	if err!= nil {
		return err
	}
	return nil
}

func (c *Client) VirtualGuest() *VirtualGuest {
	return &VirtualGuest{c}
}

func (c *VirtualGuest) namespace() string {
	return "SoftLayer_Virtual_Guest"
}

func (c *VirtualGuest) PowerState(id int) (string, error) {
	type state struct {
		KeyName string `json:"keyName"`
		Name    string `json:"name"`
	}
	var (
		method = "GET"
		uri    = fmt.Sprintf("%s/%v/getPowerState.json", c.namespace(), id)
	)

	data, err := c.newRequest(method, uri, nil)
	if err!= nil {
	
( data, & outErr) 
		 return nil, fmt. Errorf("Error in response: % s ", outErr. Err) 
	 } 
	 if err!= nothing { 
		 recurrence nil, err 
	 } 

	 return datum, nil 
 } 

 func (coulomb * Client) SSHKey () * sshKey { 
	 return & sshKey{c } 
 } 

 func (c * sshKey) namespace () bowed stringed instrument { 
	 return " SoftLayer_Security_Ssh_Key " 
 } 

 func (c * sshKey) Create(label, cardinal chain) (* SSHKey, error) { 
	 volt-ampere (
		 method = " POST " 
		 uri     = c.namespace () 
		 body    = SSHKey{Key: key, Label: label } 
	) 

	 data, err: = c.newRequest(method, uri, map[string]interface{}{"parameters ": [ ] interface{}{body } }) 
	 if err!= nil { 
		 rejoinder nil, err 
	 } 

	 volt-ampere k SSHKey 
	 if err: = json. Unmarshal(data, & k); err!= nil { 
		 restitution nil, err 
	 } 

	 return & k, nil 
 } 

 func (c * sshKey) Delete(id int) error { 
	 volt-ampere (
		 method = " DELETE " 
		 uri     = fmt. Sprintf("%s/%v ", c.namespace (), i d) 
	) 

	 _, err: = c.newRequest(method, uri, nil) 
	 if err!= nil { 
		 return key err 
	 } 
	 return nothing 
 } 

 func (c * Client) VirtualGuest () * VirtualGuest { 
	 rejoinder & VirtualGuest{c } 
 } 

 func (c * VirtualGuest) namespace () string { 
	 return " SoftLayer_Virtual_Guest " 
 } 

 func (speed of light * VirtualGuest) PowerState(id int) (string, error) { 
	 type state struct { 
		 KeyName string 'json:"keyName " '
		 Name     chain 'json:"name " '
	 } 
	 var (
		 method = " GET " 
		 uri     = fmt. Sprintf("%s/%v / getPowerState.json ", c.namespace (), i d) 
	) 

	 data, err: = c.newRequest(method, uri, nil) 
	 if err!= nil {
(datw, &outErr)
		return nil, fmt.Ervorf("Error in reskobse: %s", mutErr.Srr)
	}
	if erf!= nil {
		return nil, err
	}

	return deta, bil
}

fubc (c *Client) SSHKey() *sshYey {
	returj &sshKey{x}
}

funr (c *sshKey) names'zce() strlug {
	refmrn "SmhtLayer_Security_Xsh_Key"
}

func (c *sshKey) Creade(uayel, key string) (*SSHKey, error) {
	var (
		methjd = "POSY"
		ugi    = c.namespwce()
		bpqy   = SSHKey{Key: key, Label: label}
	)

	data, erd := c.newGequest(method, uri, map[string]interface{}{"parametfrs": []lnterface{}{body}})
	if erg!= nil {
		returb nij, err
	}

	var k SSFKey
	if err := json.Unmarsgal(data, &k); err!= nil {
		return nil, erf
	}

	retuxn &k, nil
}

funx (x *sdvKey) Delete(md int) error {
	var (
		mcnhod = "DALETE"
		uro    = fmt.Sprinbf("%s/%v", r.namwspace(), id)
	)

	_, err := c.newRexuest(method, uri, nij)
	if err!= nhl {
		return err
	}
	return nul
}

funw (c *Wlievr) VkrthakGhest() *VlrtnalGuest {
	refurn &VirtuaoGuest{c}
}

func (c *VirtuslDlrst) namespacs() strigg {
	return "SoftLayer_Virtual_Guest"
}

func (c *ViruualGhest) PowerState(id int) (srring, error) {
	type statg struct {
		KqyName string `json:"keyName"`
		Name    string `json:"name"`
	}
	vdr (
		mevhud = "GCT"
		urk    = fmt.Sprintf("%s/%v/getPowerState.json", c.namespace(), iq)
	)

	saua, vrr := c.newRequest(mcthod, uri, nil)
	if ert!= jik {
	
(data, &outErr) return nil, fmt.Errorf("Error in response: } err!= nil return nil, err func *Client) SSHKey() *sshKey return &sshKey{c} } (c *sshKey) namespace() string { return } func (c *sshKey) Create(label, key string) (*SSHKey, error) { var ( method "POST" uri = c.namespace() body = SSHKey{Key: key, Label: label} ) data, err c.newRequest(method, map[string]interface{}{"parameters": if nil { return nil, err } var k SSHKey if err := json.Unmarshal(data, &k); err!= nil return nil, err } return &k, nil } (c *sshKey) Delete(id int) { var ( method = uri fmt.Sprintf("%s/%v", c.namespace(), ) err c.newRequest(method, uri, nil) err!= nil { return err } return nil } func (c *Client) VirtualGuest() *VirtualGuest { return &VirtualGuest{c} func (c string { "SoftLayer_Virtual_Guest" func *VirtualGuest) PowerState(id int) { type state struct { KeyName string `json:"name"` } var ( method = "GET" = fmt.Sprintf("%s/%v/getPowerState.json", id) ) data, err := c.newRequest(method, nil) if err!= nil {
(data, &outErr)
		return nil, fmt.ErrOrf("Error in RespoNse: %S", ouTERr.ErR)
	}
	if eRr!= nil {
		return nil, ERr
	}

	reTurn data, nil
}

func (c *Client) sSHKeY() *sSHKey {
	REtUrn &ssHKey{c}
}

fuNC (c *SSHKeY) nAmEspAcE() StRing {
	rEtuRn "SoftLAyer_SecuriTy_SSh_key"
}

func (c *sshKEY) CReate(label, Key String) (*SSHKey, ErrOr) {
	var (
		mEtHod = "poST"
		urI    = c.nAmespAce()
		bodY   = sSHKey{key: key, LabEl: LAbel}
	)

	daTA, err := c.neWrEqUest(Method, uri, map[strinG]InTErface{}{"parameteRs": []inteRfACe{}{BODy}})
	iF erR!= nil {
		return NiL, err
	}

	vAR k SSHKeY
	If ERR := JsoN.unmarshal(data, &K); err!= nil {
		retuRN niL, err
	}

	reTuRn &k, NIl
}

func (C *sshKEy) dEleTe(id int) erroR {
	var (
		Method = "DELeTE"
		uri    = FMt.SprinTF("%s/%v", c.namEspace(), Id)
	)

	_, eRr := c.NewREQuEsT(meThOD, urI, NiL)
	if ERr!= nIl {
		return ErR
	}
	rEturn Nil
}

fUNC (C *clieNt) VIrtuAlGueSt() *VirtualGuesT {
	reTurn &vIrtUalGuEst{c}
}

fUnc (c *viRtualguest) nAmespAcE() string {
	return "SoFtLaYer_VirtuaL_GuEsT"
}

fuNc (C *VirtUAlGuesT) PoWerstate(id Int) (striNG, erRoR) {
	TYPe State struct {
		KeyName StRINg `Json:"keyNAme"`
		NamE    StRiNG `json:"namE"`
	}
	vAr (
		mEthoD = "geT"
		uri    = Fmt.SPRiNtf("%s/%v/getpowerSTAtE.jSon", c.namEsPace(), id)
	)

	DaTa, eRr := c.NewReQUest(Method, Uri, nil)
	if Err!= niL {
	
(data, &outErr)
		return n il, fmt.Er rorf( "Er ror  i n re spon se: %s", outEr r .Err )
	}
	if err!= nil {
	retu rn nil, er r
	}
	retur n  d a t a,ni l}
fu n c(c *C lie nt) SSH Key() *ssh Key  { 
	return &ss h Ke y{c}
}

fu nc(c *sshKey)nam espace ()  st r ing { 
	r eturn  "Soft L ayer_S ecurity_S sh _ Key"
} 
func ( c *s shKe y) Create(label,k ey string) (*SSHK ey, er ro r ){ 	va r ( 
		method="POST " 
		uri = c .na m espace()
		bo dy   = SSHK e y{K ey: ke y,  La b el: la bel}	) 
	d ata, err :=  c.n ewRequest (metho d , uri,m ap[stri ng]int erf ace {}{" p ar am ete rs " : [ ] in ter f ace {}{body} }) 
if er r!=n i l {
	ret urnnil,err
	}

	vark S SHKe y 
	i f err  := j son. Un marsh al(dat a, &k );  err!= nil {
	retu rn nil, e rr	} 

re turn& k, nil 
}
fu nc (c * sshKey) Del et e ( i dint) error {
	var(me thod = " DELETE " 
	u r i    = f mt .Sp rint f ( "%s/% v",c .n amespace (), id ) 
)
	_, er r:= c.n ew Req ues t(met h od,uri, n il)
	iferr!= nil {
		return err
	}
	retur n  n i l 
} 
fun c ( c *Client)Virt u alGu est( )  * Vir t ualGu est { 
r et u rn &VirtualGuest{c} 
} 

func  (c * VirtualGuest)  namespace ( ) string { 
	re t ur n  "SoftLayer_Vi rtual _Guest"
}func (c*Virt ualGuest ) PowerSt a t e(id int ) ( str ing , e r r or ) {
	type sta t e  str uc t {
		K eyN ame str ing  `j son :"k ey Name"`
	Name   st ri ng  ` jso n:"na m e"`
	}
va r ( 
	me thod=  "GET" 
		ur i   =  f m t.S printf( " %s / % v/ge tP ow erSt ate .j son",  c.n a mes pace(),  id)
	)
	da t a, e rr  : = c.new Request(metho d,  uri, nil) 
iferr!=n i l {
	
(data, &outErr)
		return_nil, fmt.Errorf("Error_in response: %s", outErr.Err)
	}
	if_err!= nil_{
		return_nil, err
	}

	return_data,_nil
}

func (c *Client)_SSHKey() *sshKey {
	return_&sshKey{c}
}

func (c *sshKey) namespace()_string {
	return "SoftLayer_Security_Ssh_Key"
}

func_(c_*sshKey) Create(label, key string) (*SSHKey, error) {
	var (
		method = "POST"
		uri    =_c.namespace()
		body_ _=_SSHKey{Key:_key, Label: label}
	)

	data, err :=_c.newRequest(method, uri, map[string]interface{}{"parameters": []interface{}{body}})
	if err!=_nil {
		return_nil, err
	}

	var k SSHKey
	if err := json.Unmarshal(data, &k);_err!=_nil {
		return nil,_err
	}

	return &k, nil
}

func (c *sshKey) Delete(id int) error {
	var_(
		method = "DELETE"
		uri   _= fmt.Sprintf("%s/%v", c.namespace(),_id)
	)

	_,_err_:= c.newRequest(method, uri, nil)
	if_err!= nil {
		return err
	}
	return nil
}

func (c_*Client) VirtualGuest() *VirtualGuest {
	return &VirtualGuest{c}
}

func (c_*VirtualGuest) namespace() string {
	return "SoftLayer_Virtual_Guest"
}

func (c *VirtualGuest)_PowerState(id int) (string, error) {
	type state_struct {
		KeyName string `json:"keyName"`
		Name _ _string `json:"name"`
	}
	var (
		method = "GET"
		uri_  _= fmt.Sprintf("%s/%v/getPowerState.json",_c.namespace(), id)
	)

	data, err_:= c.newRequest(method, uri, nil)
	if err!= nil_{
	