diff --git a/agents/dmtagent.go b/agents/dmtagent.go
index cb927bbd3..c2708bd1a 100644
--- a/agents/dmtagent.go
+++ b/agents/dmtagent.go
@@ -130,13 +130,13 @@ func (self DiameterAgent) processCCR(ccr *CCR, reqProcessor *config.DARequestPro
 	} else { // Find out maxUsage over APIs
 		switch ccr.CCRequestType {
 		case 1:
-			err = self.smg.Call("SMGenericV1.SessionStart", smgEv, &maxUsage)
+			err = self.smg.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage)
 		case 2:
-			err = self.smg.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage)
+			err = self.smg.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage)
 		case 3, 4: // Handle them together since we generate CDR for them
 			var rpl string
 			if ccr.CCRequestType == 3 {
-				err = self.smg.Call("SMGenericV1.SessionEnd", smgEv, &rpl)
+				err = self.smg.Call("SMGenericV1.TerminateSession", smgEv, &rpl)
 			} else if ccr.CCRequestType == 4 {
 				err = self.smg.Call("SMGenericV1.ChargeEvent", smgEv, &maxUsage)
 				if maxUsage == 0 {
@@ -144,7 +144,7 @@ func (self DiameterAgent) processCCR(ccr *CCR, reqProcessor *config.DARequestPro
 				}
 			}
 			if self.cgrCfg.DiameterAgentCfg().CreateCDR {
-				if errCdr := self.smg.Call("SMGenericV1.ProcessCdr", smgEv, &rpl); errCdr != nil {
+				if errCdr := self.smg.Call("SMGenericV1.ProcessCDR", smgEv, &rpl); errCdr != nil {
 					err = errCdr
 				}
 			}
diff --git a/apier/v1/smgenericbirpcv1.go b/apier/v1/smgenericbirpcv1.go
index 035d55b86..c5e5e40a5 100644
--- a/apier/v1/smgenericbirpcv1.go
+++ b/apier/v1/smgenericbirpcv1.go
@@ -37,18 +37,18 @@ type SMGenericBiRpcV1 struct {
 // Publishes methods exported by SMGenericBiRpcV1 as SMGenericV1 (so we can handle standard RPC methods via birpc socket)
 func (self *SMGenericBiRpcV1) Handlers() map[string]interface{} {
 	return map[string]interface{}{
-		"SMGenericV1.GetMaxUsage":     self.GetMaxUsage,
-		"SMGenericV1.GetLcrSuppliers": self.GetLcrSuppliers,
-		"SMGenericV1.SessionStart":    self.SessionStart,
-		"SMGenericV1.SessionUpdate":   self.SessionUpdate,
-		"SMGenericV1.SessionEnd":      self.SessionEnd,
-		"SMGenericV1.ProcessCdr":      self.ProcessCdr,
+		"SMGenericV1.MaxUsage":         self.MaxUsage,
+		"SMGenericV1.LCRSuppliers":     self.LCRSuppliers,
+		"SMGenericV1.InitiateSession":  self.InitiateSession,
+		"SMGenericV1.UpdateSession":    self.UpdateSession,
+		"SMGenericV1.TerminateSession": self.TerminateSession,
+		"SMGenericV1.ProcessCDR":       self.ProcessCDR,
 	}
 }
 
 /// Returns MaxUsage (for calls in seconds), -1 for no limit
-func (self *SMGenericBiRpcV1) GetMaxUsage(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
-	maxUsageDur, err := self.sm.GetMaxUsage(ev, clnt)
+func (self *SMGenericBiRpcV1) MaxUsage(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
+	maxUsageDur, err := self.sm.MaxUsage(ev, clnt)
 	if err != nil {
 		return utils.NewErrServerError(err)
 	}
@@ -61,8 +61,8 @@ func (self *SMGenericBiRpcV1) GetMaxUsage(clnt *rpc2.Client, ev sessionmanager.S
 }
 
 /// Returns list of suppliers which can be used for the request
-func (self *SMGenericBiRpcV1) GetLcrSuppliers(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, suppliers *[]string) error {
-	if supls, err := self.sm.GetLcrSuppliers(ev, clnt); err != nil {
+func (self *SMGenericBiRpcV1) LCRSuppliers(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, suppliers *[]string) error {
+	if supls, err := self.sm.LCRSuppliers(ev, clnt); err != nil {
 		return utils.NewErrServerError(err)
 	} else {
 		*suppliers = supls
@@ -71,8 +71,8 @@ func (self *SMGenericBiRpcV1) GetLcrSuppliers(clnt *rpc2.Client, ev sessionmanag
 }
 
 // Called on session start, returns the maximum number of seconds the session can last
-func (self *SMGenericBiRpcV1) SessionStart(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
-	if minMaxUsage, err := self.sm.SessionStart(ev, clnt); err != nil {
+func (self *SMGenericBiRpcV1) InitiateSession(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
+	if minMaxUsage, err := self.sm.InitiateSession(ev, clnt); err != nil {
 		return utils.NewErrServerError(err)
 	} else {
 		*maxUsage = minMaxUsage.Seconds()
@@ -81,8 +81,8 @@ func (self *SMGenericBiRpcV1) SessionStart(clnt *rpc2.Client, ev sessionmanager.
 }
 
 // Interim updates, returns remaining duration from the rater
-func (self *SMGenericBiRpcV1) SessionUpdate(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
-	if minMaxUsage, err := self.sm.SessionUpdate(ev, clnt); err != nil {
+func (self *SMGenericBiRpcV1) UpdateSession(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
+	if minMaxUsage, err := self.sm.UpdateSession(ev, clnt); err != nil {
 		return utils.NewErrServerError(err)
 	} else {
 		*maxUsage = minMaxUsage.Seconds()
@@ -91,8 +91,8 @@ func (self *SMGenericBiRpcV1) SessionUpdate(clnt *rpc2.Client, ev sessionmanager
 }
 
 // Called on session end, should stop debit loop
-func (self *SMGenericBiRpcV1) SessionEnd(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, reply *string) error {
-	if err := self.sm.SessionEnd(ev, clnt); err != nil {
+func (self *SMGenericBiRpcV1) TerminateSession(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, reply *string) error {
+	if err := self.sm.TerminateSession(ev, clnt); err != nil {
 		return utils.NewErrServerError(err)
 	}
 	*reply = utils.OK
@@ -110,8 +110,8 @@ func (self *SMGenericBiRpcV1) ChargeEvent(clnt *rpc2.Client, ev sessionmanager.S
 }
 
 // Called on session end, should send the CDR to CDRS
-func (self *SMGenericBiRpcV1) ProcessCdr(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, reply *string) error {
-	if err := self.sm.ProcessCdr(ev); err != nil {
+func (self *SMGenericBiRpcV1) ProcessCDR(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, reply *string) error {
+	if err := self.sm.ProcessCDR(ev); err != nil {
 		return utils.NewErrServerError(err)
 	}
 	*reply = utils.OK
diff --git a/apier/v1/smgenericv1.go b/apier/v1/smgenericv1.go
index 08471bc3d..07d09a2fa 100644
--- a/apier/v1/smgenericv1.go
+++ b/apier/v1/smgenericv1.go
@@ -18,8 +18,8 @@ type SMGenericV1 struct {
 }
 
 // Returns MaxUsage (for calls in seconds), -1 for no limit
-func (self *SMGenericV1) GetMaxUsage(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
-	maxUsageDur, err := self.sm.GetMaxUsage(ev, nil)
+func (self *SMGenericV1) MaxUsage(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
+	maxUsageDur, err := self.sm.MaxUsage(ev, nil)
 	if err != nil {
 		return utils.NewErrServerError(err)
 	}
@@ -32,8 +32,8 @@ func (self *SMGenericV1) GetMaxUsage(ev sessionmanager.SMGenericEvent, maxUsage
 }
 
 // Returns list of suppliers which can be used for the request
-func (self *SMGenericV1) GetLcrSuppliers(ev sessionmanager.SMGenericEvent, suppliers *[]string) error {
-	if supls, err := self.sm.GetLcrSuppliers(ev, nil); err != nil {
+func (self *SMGenericV1) LCRSuppliers(ev sessionmanager.SMGenericEvent, suppliers *[]string) error {
+	if supls, err := self.sm.LCRSuppliers(ev, nil); err != nil {
 		return utils.NewErrServerError(err)
 	} else {
 		*suppliers = supls
@@ -42,8 +42,8 @@ func (self *SMGenericV1) GetLcrSuppliers(ev sessionmanager.SMGenericEvent, suppl
 }
 
 // Called on session start, returns the maximum number of seconds the session can last
-func (self *SMGenericV1) SessionStart(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
-	if minMaxUsage, err := self.sm.SessionStart(ev, nil); err != nil {
+func (self *SMGenericV1) InitiateSession(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
+	if minMaxUsage, err := self.sm.InitiateSession(ev, nil); err != nil {
 		return utils.NewErrServerError(err)
 	} else {
 		*maxUsage = minMaxUsage.Seconds()
@@ -52,8 +52,8 @@ func (self *SMGenericV1) SessionStart(ev sessionmanager.SMGenericEvent, maxUsage
 }
 
 // Interim updates, returns remaining duration from the rater
-func (self *SMGenericV1) SessionUpdate(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
-	if minMaxUsage, err := self.sm.SessionUpdate(ev, nil); err != nil {
+func (self *SMGenericV1) UpdateSession(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
+	if minMaxUsage, err := self.sm.UpdateSession(ev, nil); err != nil {
 		return utils.NewErrServerError(err)
 	} else {
 		*maxUsage = minMaxUsage.Seconds()
@@ -62,8 +62,8 @@ func (self *SMGenericV1) SessionUpdate(ev sessionmanager.SMGenericEvent, maxUsag
 }
 
 // Called on session end, should stop debit loop
-func (self *SMGenericV1) SessionEnd(ev sessionmanager.SMGenericEvent, reply *string) error {
-	if err := self.sm.SessionEnd(ev, nil); err != nil {
+func (self *SMGenericV1) TerminateSession(ev sessionmanager.SMGenericEvent, reply *string) error {
+	if err := self.sm.TerminateSession(ev, nil); err != nil {
 		return utils.NewErrServerError(err)
 	}
 	*reply = utils.OK
@@ -81,8 +81,8 @@ func (self *SMGenericV1) ChargeEvent(ev sessionmanager.SMGenericEvent, maxUsage
 }
 
 // Called on session end, should send the CDR to CDRS
-func (self *SMGenericV1) ProcessCdr(ev sessionmanager.SMGenericEvent, reply *string) error {
-	if err := self.sm.ProcessCdr(ev); err != nil {
+func (self *SMGenericV1) ProcessCDR(ev sessionmanager.SMGenericEvent, reply *string) error {
+	if err := self.sm.ProcessCDR(ev); err != nil {
 		return utils.NewErrServerError(err)
 	}
 	*reply = utils.OK
@@ -143,7 +143,7 @@ func (self *SMGenericV1) ActiveSessionsCount(attrs utils.AttrSMGGetActiveSession
 // rpcclient.RpcClientConnection interface
 func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply interface{}) error {
 	switch serviceMethod {
-	case "SMGenericV1.GetMaxUsage":
+	case "SMGenericV1.MaxUsage":
 		argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
 		if !canConvert {
 			return rpcclient.ErrWrongArgsType
@@ -152,8 +152,8 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
 		if !canConvert {
 			return rpcclient.ErrWrongReplyType
 		}
-		self.GetMaxUsage(argsConverted, replyConverted)
-	case "SMGenericV1.GetLcrSuppliers":
+		self.MaxUsage(argsConverted, replyConverted)
+	case "SMGenericV1.LCRSuppliers":
 		argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
 		if !canConvert {
 			return rpcclient.ErrWrongArgsType
@@ -162,8 +162,8 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
 		if !canConvert {
 			return rpcclient.ErrWrongReplyType
 		}
-		return self.GetLcrSuppliers(argsConverted, replyConverted)
-	case "SMGenericV1.SessionStart":
+		return self.LCRSuppliers(argsConverted, replyConverted)
+	case "SMGenericV1.InitiateSession":
 		argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
 		if !canConvert {
 			return rpcclient.ErrWrongArgsType
@@ -172,8 +172,8 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
 		if !canConvert {
 			return rpcclient.ErrWrongReplyType
 		}
-		return self.SessionStart(argsConverted, replyConverted)
-	case "SMGenericV1.SessionUpdate":
+		return self.InitiateSession(argsConverted, replyConverted)
+	case "SMGenericV1.UpdateSession":
 		argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
 		if !canConvert {
 			return rpcclient.ErrWrongArgsType
@@ -182,8 +182,8 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
 		if !canConvert {
 			return rpcclient.ErrWrongReplyType
 		}
-		return self.SessionUpdate(argsConverted, replyConverted)
-	case "SMGenericV1.SessionEnd":
+		return self.UpdateSession(argsConverted, replyConverted)
+	case "SMGenericV1.TerminateSession":
 		argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
 		if !canConvert {
 			return rpcclient.ErrWrongArgsType
@@ -192,7 +192,7 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
 		if !canConvert {
 			return rpcclient.ErrWrongReplyType
 		}
-		return self.SessionEnd(argsConverted, replyConverted)
+		return self.TerminateSession(argsConverted, replyConverted)
 	case "SMGenericV1.ChargeEvent":
 		argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
 		if !canConvert {
@@ -203,7 +203,7 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
 			return rpcclient.ErrWrongReplyType
 		}
 		return self.ChargeEvent(argsConverted, replyConverted)
-	case "SMGenericV1.ProcessCdr":
+	case "SMGenericV1.ProcessCDR":
 		argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
 		if !canConvert {
 			return rpcclient.ErrWrongArgsType
@@ -212,7 +212,7 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
 		if !canConvert {
 			return rpcclient.ErrWrongReplyType
 		}
-		return self.ProcessCdr(argsConverted, replyConverted)
+		return self.ProcessCDR(argsConverted, replyConverted)
 	case "SMGenericV1.ActiveSessions":
 		argsConverted, canConvert := args.(utils.AttrSMGGetActiveSessions)
 		if !canConvert {
diff --git a/apier/v1/smgenericv1_it_test.go b/apier/v1/smgenericv1_it_test.go
index 17da136f8..f1cc270d0 100644
--- a/apier/v1/smgenericv1_it_test.go
+++ b/apier/v1/smgenericv1_it_test.go
@@ -149,7 +149,7 @@ func TestSMGV1GetMaxUsage(t *testing.T) {
 	setupReq := &sessionmanager.SMGenericEvent{utils.REQTYPE: utils.META_PREPAID, utils.TENANT: "cgrates.org",
 		utils.ACCOUNT: "1003", utils.DESTINATION: "1002", utils.SETUP_TIME: "2015-11-10T15:20:00Z"}
 	var maxTime float64
-	if err := smgV1Rpc.Call("SMGenericV1.GetMaxUsage", setupReq, &maxTime); err != nil {
+	if err := smgV1Rpc.Call("SMGenericV1.MaxUsage", setupReq, &maxTime); err != nil {
 		t.Error(err)
 	} else if maxTime != 2700 {
 		t.Errorf("Calling ApierV2.MaxUsage got maxTime: %f", maxTime)
diff --git a/sessionmanager/data_it_test.go b/sessionmanager/data_it_test.go
index ee73c7f38..9f7633780 100644
--- a/sessionmanager/data_it_test.go
+++ b/sessionmanager/data_it_test.go
@@ -109,7 +109,7 @@ func TestSMGDataLastUsedData(t *testing.T) {
 		utils.USAGE:       "1048576",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -137,7 +137,7 @@ func TestSMGDataLastUsedData(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "20000",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -165,7 +165,7 @@ func TestSMGDataLastUsedData(t *testing.T) {
 		utils.LastUsed:    "0",
 	}
 	var rpl string
-	if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
+	if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
 		t.Error(err)
 	}
 	eAcntVal = 49999979520.000000 //20480
@@ -204,7 +204,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
 		utils.USAGE:       "1048576",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -236,7 +236,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "20000",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -267,7 +267,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "20000",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -298,7 +298,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "20000",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -329,7 +329,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "20000",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -360,7 +360,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
 		utils.LastUsed:    "0",
 	}
 	var rpl string
-	if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
+	if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
 		t.Error(err)
 	}
 	eAcntVal = 49999897600.000000
@@ -404,7 +404,7 @@ func TestSMGDataDerivedChargingNoCredit(t *testing.T) {
 		utils.USAGE:       "100",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	// the second derived charging run has no credit
@@ -448,7 +448,7 @@ func TestSMGDataTTLExpired(t *testing.T) {
 		utils.USAGE:       "1048576",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -497,7 +497,7 @@ func TestSMGDataTTLExpiredMultiUpdates(t *testing.T) {
 		utils.USAGE:       "1048576",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -530,7 +530,7 @@ func TestSMGDataTTLExpiredMultiUpdates(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "20000",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -585,7 +585,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
 		utils.USAGE:       "1048576",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -617,7 +617,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "0",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -648,7 +648,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "0",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -679,7 +679,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "0",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -710,7 +710,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "0",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -741,7 +741,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
 		utils.LastUsed:    "0",
 	}
 	var rpl string
-	if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
+	if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
 		t.Error(err)
 	}
 	eAcntVal = 49997767680.000000 // refunded
@@ -785,7 +785,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
 		utils.USAGE:       "1048576",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -818,7 +818,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "600",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -849,7 +849,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "600",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -880,7 +880,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "600",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -911,7 +911,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
 		utils.USAGE:       "1048576",
 		utils.LastUsed:    "600",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 1.048576e+06 {
@@ -942,7 +942,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
 		utils.LastUsed:    "0",
 	}
 	var rpl string
-	if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
+	if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
 		t.Error(err)
 	}
 	eAcntVal = 49997757440.000000 // 10240 (from the start)
diff --git a/sessionmanager/smg_it_test.go b/sessionmanager/smg_it_test.go
index b14e4adf0..1ae469fbf 100644
--- a/sessionmanager/smg_it_test.go
+++ b/sessionmanager/smg_it_test.go
@@ -130,7 +130,7 @@ func TestSMGVoiceMonetaryRefund(t *testing.T) {
 		utils.USAGE:       "1m30s",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 90 {
@@ -160,7 +160,7 @@ func TestSMGVoiceMonetaryRefund(t *testing.T) {
 		utils.USAGE:       "1m",
 	}
 	var rpl string
-	if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
+	if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
 		t.Error(err)
 	}
 	eAcntVal = 8.8
@@ -191,7 +191,7 @@ func TestSMGVoiceVoiceRefund(t *testing.T) {
 		utils.USAGE:       "1m30s",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 90 {
@@ -221,7 +221,7 @@ func TestSMGVoiceVoiceRefund(t *testing.T) {
 		utils.USAGE:       "1m",
 	}
 	var rpl string
-	if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
+	if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
 		t.Error(err)
 	}
 	eAcntVal = 150.0
@@ -259,7 +259,7 @@ func TestSMGVoiceMixedRefund(t *testing.T) {
 		utils.USAGE:       "1m30s",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 90 {
@@ -291,7 +291,7 @@ func TestSMGVoiceMixedRefund(t *testing.T) {
 		utils.USAGE:       "1m",
 	}
 	var rpl string
-	if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
+	if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
 		t.Error(err)
 	}
 	eVoiceVal = 90.0
@@ -334,7 +334,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
 		utils.USAGE:       "2m",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 120 {
@@ -360,7 +360,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
 		utils.USAGE:       "2m",
 		utils.LastUsed:    "1m30s",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 120 {
@@ -386,7 +386,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
 		utils.USAGE:       "2m",
 		utils.LastUsed:    "2m30s",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 120 {
@@ -412,7 +412,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
 		utils.USAGE:       "1m",
 	}
 	var rpl string
-	if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
+	if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
 		t.Error(err)
 	}
 	eAcntVal = 7.59
@@ -451,7 +451,7 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
 		utils.USAGE:       "2m",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 120 {
@@ -477,7 +477,7 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
 		utils.USAGE:       "2m",
 		utils.LastUsed:    "30s",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 120 {
@@ -503,7 +503,7 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
 		utils.LastUsed:    "0s",
 	}
 	var rpl string
-	if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
+	if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
 		t.Error(err)
 	}
 	eAcntVal = 6.590000
@@ -542,7 +542,7 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
 		utils.USAGE:       "2m",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 120 {
@@ -568,7 +568,7 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
 		utils.USAGE:       "2m",
 		utils.LastUsed:    "13s",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 120 {
@@ -594,7 +594,7 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
 		utils.LastUsed:    "0s",
 	}
 	var rpl string
-	if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
+	if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
 		t.Error(err)
 	}
 	eAcntVal = 5.590000
@@ -633,7 +633,7 @@ func TestSMGVoiceSessionTTL(t *testing.T) {
 		utils.USAGE:       "2m",
 	}
 	var maxUsage float64
-	if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 120 {
@@ -667,7 +667,7 @@ func TestSMGVoiceSessionTTL(t *testing.T) {
 		utils.USAGE:       "2m",
 		utils.LastUsed:    "30s",
 	}
-	if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
+	if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
 		t.Error(err)
 	}
 	if maxUsage != 120 {
diff --git a/sessionmanager/smgeneric.go b/sessionmanager/smgeneric.go
index eb4873bd8..005750af1 100644
--- a/sessionmanager/smgeneric.go
+++ b/sessionmanager/smgeneric.go
@@ -258,7 +258,7 @@ func (self *SMGeneric) sessionRelocate(sessionID, initialID string) error {
 
 // Methods to apply on sessions, mostly exported through RPC/Bi-RPC
 //Calculates maximum usage allowed for gevent
-func (self *SMGeneric) GetMaxUsage(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
+func (self *SMGeneric) MaxUsage(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
 	gev[utils.EVENT_NAME] = utils.CGR_AUTHORIZATION
 	storedCdr := gev.AsStoredCdr(config.CgrConfig(), self.timezone)
 	var maxDur float64
@@ -268,7 +268,7 @@ func (self *SMGeneric) GetMaxUsage(gev SMGenericEvent, clnt *rpc2.Client) (time.
 	return time.Duration(maxDur), nil
 }
 
-func (self *SMGeneric) GetLcrSuppliers(gev SMGenericEvent, clnt *rpc2.Client) ([]string, error) {
+func (self *SMGeneric) LCRSuppliers(gev SMGenericEvent, clnt *rpc2.Client) ([]string, error) {
 	gev[utils.EVENT_NAME] = utils.CGR_LCR_REQUEST
 	cd, err := gev.AsLcrRequest().AsCallDescriptor(self.timezone)
 	cd.CgrID = gev.GetCgrId(self.timezone)
@@ -287,12 +287,12 @@ func (self *SMGeneric) GetLcrSuppliers(gev SMGenericEvent, clnt *rpc2.Client) ([
 }
 
 // Called on session start
-func (self *SMGeneric) SessionStart(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
+func (self *SMGeneric) InitiateSession(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
 	if err := self.sessionStart(gev, getClientConnId(clnt)); err != nil {
 		self.sessionEnd(gev.GetUUID(), 0)
 		return nilDuration, err
 	}
-	d, err := self.SessionUpdate(gev, clnt)
+	d, err := self.UpdateSession(gev, clnt)
 	if err != nil || d == 0 {
 		self.sessionEnd(gev.GetUUID(), 0)
 	}
@@ -300,7 +300,7 @@ func (self *SMGeneric) SessionStart(gev SMGenericEvent, clnt *rpc2.Client) (time
 }
 
 // Execute debits for usage/maxUsage
-func (self *SMGeneric) SessionUpdate(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
+func (self *SMGeneric) UpdateSession(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
 	self.resetTerminatorTimer(gev.GetUUID(), gev.GetSessionTTL(), gev.GetSessionTTLLastUsed(), gev.GetSessionTTLUsage())
 	if initialID, err := gev.GetFieldAsString(utils.InitialOriginID); err == nil {
 		err := self.sessionRelocate(gev.GetUUID(), initialID)
@@ -342,7 +342,7 @@ func (self *SMGeneric) SessionUpdate(gev SMGenericEvent, clnt *rpc2.Client) (tim
 }
 
 // Called on session end, should stop debit loop
-func (self *SMGeneric) SessionEnd(gev SMGenericEvent, clnt *rpc2.Client) error {
+func (self *SMGeneric) TerminateSession(gev SMGenericEvent, clnt *rpc2.Client) error {
 	if initialID, err := gev.GetFieldAsString(utils.InitialOriginID); err == nil {
 		err := self.sessionRelocate(gev.GetUUID(), initialID)
 		if err == utils.ErrNotFound { // Session was already relocated, create a new  session with this update
@@ -488,7 +488,7 @@ func (self *SMGeneric) ChargeEvent(gev SMGenericEvent, clnt *rpc2.Client) (maxDu
 	return maxDur, nil
 }
 
-func (self *SMGeneric) ProcessCdr(gev SMGenericEvent) error {
+func (self *SMGeneric) ProcessCDR(gev SMGenericEvent) error {
 	var reply string
 	if err := self.cdrsrv.Call("CdrsV1.ProcessCdr", gev.AsStoredCdr(self.cgrCfg, self.timezone), &reply); err != nil {
 		return err