diff --git a/models/runtime_server.go b/models/runtime_server.go
index 8afd71b3..4b3d955f 100644
--- a/models/runtime_server.go
+++ b/models/runtime_server.go
@@ -33,7 +33,7 @@ import (
 // RuntimeServer Runtime Server
 //
 // Runtime transient server properties
-// Example: {"address":"127.0.0.5","admin_state":"ready","operational_state":"up","port":80,"server_id":1,"server_name":"web_server"}
+// Example: {"address":"142.250.191.142","admin_state":"ready","agent_addr":"127.0.0.1","agent_port":80,"agent_state":0,"backend_forced_id":0,"backend_id":2,"backend_name":"myservers","check_addr":"142.250.191.143","check_health":0,"check_port":80,"check_result":2,"check_state":6,"check_status":17,"forced_id":0,"fqdn":"server.com","id":1,"iweight":1,"last_time_change":123,"name":"server1","operational_state":"up","port":80,"srvrecord":"_myservice._tcp.example.local","use_ssl":false,"uweight":1}
 //
 // swagger:model runtime_server
 type RuntimeServer struct {
@@ -48,10 +48,82 @@ type RuntimeServer struct {
 	// +kubebuilder:validation:Enum=ready;maint;drain;
 	AdminState string `json:"admin_state,omitempty"`
 
+	// agent addr
+	// Read Only: true
+	AgentAddr string `json:"agent_addr,omitempty"`
+
+	// agent port
+	// Read Only: true
+	// Maximum: 65535
+	// Minimum: 1
+	// +kubebuilder:validation:Maximum=65535
+	// +kubebuilder:validation:Minimum=1
+	AgentPort *int64 `json:"agent_port,omitempty"`
+
+	// agent state
+	// Read Only: true
+	AgentState *int64 `json:"agent_state,omitempty"`
+
+	// backend forced id
+	// Read Only: true
+	BackendForcedID *int64 `json:"backend_forced_id,omitempty"`
+
+	// backend id
+	// Read Only: true
+	BackendID *int64 `json:"backend_id,omitempty"`
+
+	// backend name
+	// Read Only: true
+	BackendName string `json:"backend_name,omitempty"`
+
+	// check addr
+	// Read Only: true
+	CheckAddr string `json:"check_addr,omitempty"`
+
+	// check health
+	// Read Only: true
+	CheckHealth *int64 `json:"check_health,omitempty"`
+
+	// check port
+	// Read Only: true
+	// Maximum: 65535
+	// Minimum: 1
+	// +kubebuilder:validation:Maximum=65535
+	// +kubebuilder:validation:Minimum=1
+	CheckPort *int64 `json:"check_port,omitempty"`
+
+	// check result
+	// Read Only: true
+	CheckResult *int64 `json:"check_result,omitempty"`
+
+	// check state
+	// Read Only: true
+	CheckState *int64 `json:"check_state,omitempty"`
+
+	// check status
+	// Read Only: true
+	CheckStatus *int64 `json:"check_status,omitempty"`
+
+	// foreced id
+	// Read Only: true
+	ForecedID *int64 `json:"foreced_id,omitempty"`
+
+	// fqdn
+	// Read Only: true
+	Fqdn string `json:"fqdn,omitempty"`
+
 	// id
 	// Read Only: true
 	ID string `json:"id,omitempty"`
 
+	// iweight
+	// Read Only: true
+	Iweight *int64 `json:"iweight,omitempty"`
+
+	// last time change
+	// Read Only: true
+	LastTimeChange *int64 `json:"last_time_change,omitempty"`
+
 	// name
 	// Read Only: true
 	Name string `json:"name,omitempty"`
@@ -68,6 +140,18 @@ type RuntimeServer struct {
 	// +kubebuilder:validation:Maximum=65535
 	// +kubebuilder:validation:Minimum=1
 	Port *int64 `json:"port,omitempty"`
+
+	// srvrecord
+	// Read Only: true
+	Srvrecord string `json:"srvrecord,omitempty"`
+
+	// use ssl
+	// Read Only: true
+	UseSsl *bool `json:"use_ssl,omitempty"`
+
+	// uweight
+	// Read Only: true
+	Uweight *int64 `json:"uweight,omitempty"`
 }
 
 // Validate validates this runtime server
@@ -82,6 +166,14 @@ func (m *RuntimeServer) Validate(formats strfmt.Registry) error {
 		res = append(res, err)
 	}
 
+	if err := m.validateAgentPort(formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.validateCheckPort(formats); err != nil {
+		res = append(res, err)
+	}
+
 	if err := m.validateOperationalState(formats); err != nil {
 		res = append(res, err)
 	}
@@ -153,6 +245,38 @@ func (m *RuntimeServer) validateAdminState(formats strfmt.Registry) error {
 	return nil
 }
 
+func (m *RuntimeServer) validateAgentPort(formats strfmt.Registry) error {
+	if swag.IsZero(m.AgentPort) { // not required
+		return nil
+	}
+
+	if err := validate.MinimumInt("agent_port", "body", *m.AgentPort, 1, false); err != nil {
+		return err
+	}
+
+	if err := validate.MaximumInt("agent_port", "body", *m.AgentPort, 65535, false); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) validateCheckPort(formats strfmt.Registry) error {
+	if swag.IsZero(m.CheckPort) { // not required
+		return nil
+	}
+
+	if err := validate.MinimumInt("check_port", "body", *m.CheckPort, 1, false); err != nil {
+		return err
+	}
+
+	if err := validate.MaximumInt("check_port", "body", *m.CheckPort, 65535, false); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 var runtimeServerTypeOperationalStatePropEnum []interface{}
 
 func init() {
@@ -222,10 +346,74 @@ func (m *RuntimeServer) ContextValidate(ctx context.Context, formats strfmt.Regi
 		res = append(res, err)
 	}
 
+	if err := m.contextValidateAgentAddr(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateAgentPort(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateAgentState(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateBackendForcedID(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateBackendID(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateBackendName(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateCheckAddr(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateCheckHealth(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateCheckPort(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateCheckResult(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateCheckState(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateCheckStatus(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateForecedID(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateFqdn(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
 	if err := m.contextValidateID(ctx, formats); err != nil {
 		res = append(res, err)
 	}
 
+	if err := m.contextValidateIweight(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateLastTimeChange(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
 	if err := m.contextValidateName(ctx, formats); err != nil {
 		res = append(res, err)
 	}
@@ -234,6 +422,18 @@ func (m *RuntimeServer) ContextValidate(ctx context.Context, formats strfmt.Regi
 		res = append(res, err)
 	}
 
+	if err := m.contextValidateSrvrecord(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateUseSsl(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
+	if err := m.contextValidateUweight(ctx, formats); err != nil {
+		res = append(res, err)
+	}
+
 	if len(res) > 0 {
 		return errors.CompositeValidationError(res...)
 	}
@@ -249,6 +449,132 @@ func (m *RuntimeServer) contextValidateAddress(ctx context.Context, formats strf
 	return nil
 }
 
+func (m *RuntimeServer) contextValidateAgentAddr(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "agent_addr", "body", string(m.AgentAddr)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateAgentPort(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "agent_port", "body", m.AgentPort); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateAgentState(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "agent_state", "body", m.AgentState); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateBackendForcedID(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "backend_forced_id", "body", m.BackendForcedID); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateBackendID(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "backend_id", "body", m.BackendID); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateBackendName(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "backend_name", "body", string(m.BackendName)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateCheckAddr(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "check_addr", "body", string(m.CheckAddr)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateCheckHealth(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "check_health", "body", m.CheckHealth); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateCheckPort(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "check_port", "body", m.CheckPort); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateCheckResult(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "check_result", "body", m.CheckResult); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateCheckState(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "check_state", "body", m.CheckState); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateCheckStatus(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "check_status", "body", m.CheckStatus); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateForecedID(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "foreced_id", "body", m.ForecedID); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateFqdn(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "fqdn", "body", string(m.Fqdn)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (m *RuntimeServer) contextValidateID(ctx context.Context, formats strfmt.Registry) error {
 
 	if err := validate.ReadOnly(ctx, "id", "body", string(m.ID)); err != nil {
@@ -258,6 +584,24 @@ func (m *RuntimeServer) contextValidateID(ctx context.Context, formats strfmt.Re
 	return nil
 }
 
+func (m *RuntimeServer) contextValidateIweight(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "iweight", "body", m.Iweight); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateLastTimeChange(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "last_time_change", "body", m.LastTimeChange); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (m *RuntimeServer) contextValidateName(ctx context.Context, formats strfmt.Registry) error {
 
 	if err := validate.ReadOnly(ctx, "name", "body", string(m.Name)); err != nil {
@@ -276,6 +620,33 @@ func (m *RuntimeServer) contextValidatePort(ctx context.Context, formats strfmt.
 	return nil
 }
 
+func (m *RuntimeServer) contextValidateSrvrecord(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "srvrecord", "body", string(m.Srvrecord)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateUseSsl(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "use_ssl", "body", m.UseSsl); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *RuntimeServer) contextValidateUweight(ctx context.Context, formats strfmt.Registry) error {
+
+	if err := validate.ReadOnly(ctx, "uweight", "body", m.Uweight); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // MarshalBinary interface implementation
 func (m *RuntimeServer) MarshalBinary() ([]byte, error) {
 	if m == nil {
diff --git a/models/runtime_server_compare_test.go b/models/runtime_server_compare_test.go
index 06601d60..045c385b 100644
--- a/models/runtime_server_compare_test.go
+++ b/models/runtime_server_compare_test.go
@@ -86,7 +86,21 @@ func TestRuntimeServerEqualFalse(t *testing.T) {
 		if err != nil {
 			t.Error(err)
 		}
+		result.AgentPort = Ptr(*sample.AgentPort + 1)
+		result.AgentState = Ptr(*sample.AgentState + 1)
+		result.BackendForcedID = Ptr(*sample.BackendForcedID + 1)
+		result.BackendID = Ptr(*sample.BackendID + 1)
+		result.CheckHealth = Ptr(*sample.CheckHealth + 1)
+		result.CheckPort = Ptr(*sample.CheckPort + 1)
+		result.CheckResult = Ptr(*sample.CheckResult + 1)
+		result.CheckState = Ptr(*sample.CheckState + 1)
+		result.CheckStatus = Ptr(*sample.CheckStatus + 1)
+		result.ForecedID = Ptr(*sample.ForecedID + 1)
+		result.Iweight = Ptr(*sample.Iweight + 1)
+		result.LastTimeChange = Ptr(*sample.LastTimeChange + 1)
 		result.Port = Ptr(*sample.Port + 1)
+		result.UseSsl = Ptr(!*sample.UseSsl)
+		result.Uweight = Ptr(*sample.Uweight + 1)
 		samples = append(samples, struct {
 			a, b RuntimeServer
 		}{sample, result})
@@ -166,7 +180,21 @@ func TestRuntimeServerDiffFalse(t *testing.T) {
 		if err != nil {
 			t.Error(err)
 		}
+		result.AgentPort = Ptr(*sample.AgentPort + 1)
+		result.AgentState = Ptr(*sample.AgentState + 1)
+		result.BackendForcedID = Ptr(*sample.BackendForcedID + 1)
+		result.BackendID = Ptr(*sample.BackendID + 1)
+		result.CheckHealth = Ptr(*sample.CheckHealth + 1)
+		result.CheckPort = Ptr(*sample.CheckPort + 1)
+		result.CheckResult = Ptr(*sample.CheckResult + 1)
+		result.CheckState = Ptr(*sample.CheckState + 1)
+		result.CheckStatus = Ptr(*sample.CheckStatus + 1)
+		result.ForecedID = Ptr(*sample.ForecedID + 1)
+		result.Iweight = Ptr(*sample.Iweight + 1)
+		result.LastTimeChange = Ptr(*sample.LastTimeChange + 1)
 		result.Port = Ptr(*sample.Port + 1)
+		result.UseSsl = Ptr(!*sample.UseSsl)
+		result.Uweight = Ptr(*sample.Uweight + 1)
 		samples = append(samples, struct {
 			a, b RuntimeServer
 		}{sample, result})
@@ -175,7 +203,7 @@ func TestRuntimeServerDiffFalse(t *testing.T) {
 	for _, sample := range samples {
 		result := sample.a.Diff(sample.b)
 		listDiffFields := GetListOfDiffFields(result)
-		if len(listDiffFields) != 6 {
+		if len(listDiffFields) != 25 {
 			json := jsoniter.ConfigCompatibleWithStandardLibrary
 			a, err := json.Marshal(&sample.a)
 			if err != nil {
@@ -185,7 +213,7 @@ func TestRuntimeServerDiffFalse(t *testing.T) {
 			if err != nil {
 				t.Error(err)
 			}
-			t.Errorf("Expected RuntimeServer to be different in 6 cases, but it is not (%d) %s %s", len(result), a, b)
+			t.Errorf("Expected RuntimeServer to be different in 25 cases, but it is not (%d) %s %s", len(result), a, b)
 		}
 	}
 }
diff --git a/models/runtimeserver_diff_generated.go b/models/runtimeserver_diff_generated.go
index 480a31c0..ec64d7c7 100644
--- a/models/runtimeserver_diff_generated.go
+++ b/models/runtimeserver_diff_generated.go
@@ -29,9 +29,57 @@ func (rec RuntimeServer) Diff(obj RuntimeServer, opts ...eqdiff.GoMethodGenOptio
 	if rec.AdminState != obj.AdminState {
 		diff["AdminState"] = []interface{}{rec.AdminState, obj.AdminState}
 	}
+	if rec.AgentAddr != obj.AgentAddr {
+		diff["AgentAddr"] = []interface{}{rec.AgentAddr, obj.AgentAddr}
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.AgentPort, obj.AgentPort, opts...) {
+		diff["AgentPort."+diffKey] = diffValue
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.AgentState, obj.AgentState, opts...) {
+		diff["AgentState."+diffKey] = diffValue
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.BackendForcedID, obj.BackendForcedID, opts...) {
+		diff["BackendForcedID."+diffKey] = diffValue
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.BackendID, obj.BackendID, opts...) {
+		diff["BackendID."+diffKey] = diffValue
+	}
+	if rec.BackendName != obj.BackendName {
+		diff["BackendName"] = []interface{}{rec.BackendName, obj.BackendName}
+	}
+	if rec.CheckAddr != obj.CheckAddr {
+		diff["CheckAddr"] = []interface{}{rec.CheckAddr, obj.CheckAddr}
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.CheckHealth, obj.CheckHealth, opts...) {
+		diff["CheckHealth."+diffKey] = diffValue
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.CheckPort, obj.CheckPort, opts...) {
+		diff["CheckPort."+diffKey] = diffValue
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.CheckResult, obj.CheckResult, opts...) {
+		diff["CheckResult."+diffKey] = diffValue
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.CheckState, obj.CheckState, opts...) {
+		diff["CheckState."+diffKey] = diffValue
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.CheckStatus, obj.CheckStatus, opts...) {
+		diff["CheckStatus."+diffKey] = diffValue
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.ForecedID, obj.ForecedID, opts...) {
+		diff["ForecedID."+diffKey] = diffValue
+	}
+	if rec.Fqdn != obj.Fqdn {
+		diff["Fqdn"] = []interface{}{rec.Fqdn, obj.Fqdn}
+	}
 	if rec.ID != obj.ID {
 		diff["ID"] = []interface{}{rec.ID, obj.ID}
 	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.Iweight, obj.Iweight, opts...) {
+		diff["Iweight."+diffKey] = diffValue
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.LastTimeChange, obj.LastTimeChange, opts...) {
+		diff["LastTimeChange."+diffKey] = diffValue
+	}
 	if rec.Name != obj.Name {
 		diff["Name"] = []interface{}{rec.Name, obj.Name}
 	}
@@ -41,5 +89,14 @@ func (rec RuntimeServer) Diff(obj RuntimeServer, opts ...eqdiff.GoMethodGenOptio
 	for diffKey, diffValue := range DiffPointerInt64(rec.Port, obj.Port, opts...) {
 		diff["Port."+diffKey] = diffValue
 	}
+	if rec.Srvrecord != obj.Srvrecord {
+		diff["Srvrecord"] = []interface{}{rec.Srvrecord, obj.Srvrecord}
+	}
+	for diffKey, diffValue := range DiffPointerBool(rec.UseSsl, obj.UseSsl, opts...) {
+		diff["UseSsl."+diffKey] = diffValue
+	}
+	for diffKey, diffValue := range DiffPointerInt64(rec.Uweight, obj.Uweight, opts...) {
+		diff["Uweight."+diffKey] = diffValue
+	}
 	return diff
 }
diff --git a/models/runtimeserver_equal_generated.go b/models/runtimeserver_equal_generated.go
index 803bbe8a..612b4538 100644
--- a/models/runtimeserver_equal_generated.go
+++ b/models/runtimeserver_equal_generated.go
@@ -24,8 +24,27 @@ import (
 func (rec RuntimeServer) Equal(obj RuntimeServer, opts ...eqdiff.GoMethodGenOptions) bool {
 	return rec.Address == obj.Address &&
 		rec.AdminState == obj.AdminState &&
+		rec.AgentAddr == obj.AgentAddr &&
+		EqualPointerInt64(rec.AgentPort, obj.AgentPort, opts...) &&
+		EqualPointerInt64(rec.AgentState, obj.AgentState, opts...) &&
+		EqualPointerInt64(rec.BackendForcedID, obj.BackendForcedID, opts...) &&
+		EqualPointerInt64(rec.BackendID, obj.BackendID, opts...) &&
+		rec.BackendName == obj.BackendName &&
+		rec.CheckAddr == obj.CheckAddr &&
+		EqualPointerInt64(rec.CheckHealth, obj.CheckHealth, opts...) &&
+		EqualPointerInt64(rec.CheckPort, obj.CheckPort, opts...) &&
+		EqualPointerInt64(rec.CheckResult, obj.CheckResult, opts...) &&
+		EqualPointerInt64(rec.CheckState, obj.CheckState, opts...) &&
+		EqualPointerInt64(rec.CheckStatus, obj.CheckStatus, opts...) &&
+		EqualPointerInt64(rec.ForecedID, obj.ForecedID, opts...) &&
+		rec.Fqdn == obj.Fqdn &&
 		rec.ID == obj.ID &&
+		EqualPointerInt64(rec.Iweight, obj.Iweight, opts...) &&
+		EqualPointerInt64(rec.LastTimeChange, obj.LastTimeChange, opts...) &&
 		rec.Name == obj.Name &&
 		rec.OperationalState == obj.OperationalState &&
-		EqualPointerInt64(rec.Port, obj.Port, opts...)
+		EqualPointerInt64(rec.Port, obj.Port, opts...) &&
+		rec.Srvrecord == obj.Srvrecord &&
+		EqualPointerBool(rec.UseSsl, obj.UseSsl, opts...) &&
+		EqualPointerInt64(rec.Uweight, obj.Uweight, opts...)
 }
diff --git a/runtime/servers.go b/runtime/servers.go
index 25917201..3d15e1b0 100644
--- a/runtime/servers.go
+++ b/runtime/servers.go
@@ -127,6 +127,12 @@ func (s *SingleRuntime) SetServerAgentSend(backend, server string, send string)
 	return s.Execute(cmd)
 }
 
+// SetServerSSL set SSL for server
+func (s *SingleRuntime) SetServerSSL(backend, server string, ssl string) error {
+	cmd := fmt.Sprintf("set server %s/%s ssl %s", backend, server, ssl)
+	return s.Execute(cmd)
+}
+
 // GetServersState returns servers runtime state
 func (s *SingleRuntime) GetServersState(backend string) (models.RuntimeServers, error) {
 	cmd := "show servers state " + backend
@@ -182,18 +188,16 @@ func parseRuntimeServers(output string) (models.RuntimeServers, error) {
 func parseRuntimeServer(line string) *models.RuntimeServer {
 	fields := strings.Split(line, " ")
 
-	if len(fields) < 19 {
+	if len(fields) < 25 {
 		return nil
 	}
 
-	p, err := strconv.ParseInt(fields[18], 10, 64)
-	var port *int64
+	bID, err := strconv.ParseInt(fields[0], 10, 64)
+	var backendID *int64
 	if err == nil {
-		port = &p
+		backendID = &bID
 	}
 
-	admState, _ := misc.GetServerAdminState(fields[6])
-
 	var opState string
 	switch fields[5] {
 	case "0":
@@ -204,12 +208,117 @@ func parseRuntimeServer(line string) *models.RuntimeServer {
 		opState = "up"
 	}
 
+	admState, _ := misc.GetServerAdminState(fields[6])
+
+	uW, err := strconv.ParseInt(fields[7], 10, 64)
+	var uWeight *int64
+	if err == nil {
+		uWeight = &uW
+	}
+
+	iW, err := strconv.ParseInt(fields[8], 10, 64)
+	var iWeight *int64
+	if err == nil {
+		iWeight = &iW
+	}
+
+	lTC, err := strconv.ParseInt(fields[9], 10, 64)
+	var lastTimeChange *int64
+	if err == nil {
+		lastTimeChange = &lTC
+	}
+
+	cStatus, err := strconv.ParseInt(fields[10], 10, 64)
+	var checkStatus *int64
+	if err == nil {
+		checkStatus = &cStatus
+	}
+
+	cResult, err := strconv.ParseInt(fields[11], 10, 64)
+	var checkResult *int64
+	if err == nil {
+		checkResult = &cResult
+	}
+
+	cHealth, err := strconv.ParseInt(fields[12], 10, 64)
+	var checkHealth *int64
+	if err == nil {
+		checkHealth = &cHealth
+	}
+
+	cState, err := strconv.ParseInt(fields[13], 10, 64)
+	var checkState *int64
+	if err == nil {
+		checkState = &cState
+	}
+
+	aState, err := strconv.ParseInt(fields[14], 10, 64)
+	var agentState *int64
+	if err == nil {
+		agentState = &aState
+	}
+
+	bFID, err := strconv.ParseInt(fields[15], 10, 64)
+	var backendForcedID *int64
+	if err == nil {
+		backendForcedID = &bFID
+	}
+
+	fID, err := strconv.ParseInt(fields[16], 10, 64)
+	var forcedID *int64
+	if err == nil {
+		forcedID = &fID
+	}
+
+	p, err := strconv.ParseInt(fields[18], 10, 64)
+	var port *int64
+	if err == nil {
+		port = &p
+	}
+
+	uSSL, err := strconv.ParseBool(fields[20])
+	var useSSL *bool
+	if err == nil {
+		useSSL = &uSSL
+	}
+
+	cPort, err := strconv.ParseInt(fields[21], 10, 64)
+	var checkPort *int64
+	if err == nil {
+		checkPort = &cPort
+	}
+
+	aPort, err := strconv.ParseInt(fields[24], 10, 64)
+	var agentPort *int64
+	if err == nil {
+		agentPort = &aPort
+	}
+
 	return &models.RuntimeServer{
+		BackendID:        backendID,
+		BackendName:      fields[1],
+		ID:               fields[2],
 		Name:             fields[3],
 		Address:          fields[4],
-		Port:             port,
-		ID:               fields[2],
 		AdminState:       admState,
 		OperationalState: opState,
+		Uweight:          uWeight,
+		Iweight:          iWeight,
+		LastTimeChange:   lastTimeChange,
+		CheckStatus:      checkStatus,
+		CheckResult:      checkResult,
+		CheckHealth:      checkHealth,
+		CheckState:       checkState,
+		AgentState:       agentState,
+		BackendForcedID:  backendForcedID,
+		ForecedID:        forcedID,
+		Fqdn:             fields[17],
+		Port:             port,
+		Srvrecord:        fields[19],
+		UseSsl:           useSSL,
+		CheckPort:        checkPort,
+		CheckAddr:        fields[22],
+		AgentAddr:        fields[23],
+		AgentPort:        agentPort,
 	}
 }
diff --git a/specification/build/haproxy_spec.yaml b/specification/build/haproxy_spec.yaml
index 807be804..95f7afab 100644
--- a/specification/build/haproxy_spec.yaml
+++ b/specification/build/haproxy_spec.yaml
@@ -9729,12 +9729,31 @@ definitions:
   runtime_server:
     description: Runtime transient server properties
     example:
-      address: 127.0.0.5
+      address: 142.250.191.142
       admin_state: ready
+      agent_addr: 127.0.0.1
+      agent_port: 80
+      agent_state: 0
+      backend_forced_id: 0
+      backend_id: 2
+      backend_name: myservers
+      check_addr: 142.250.191.143
+      check_health: 0
+      check_port: 80
+      check_result: 2
+      check_state: 6
+      check_status: 17
+      forced_id: 0
+      fqdn: server.com
+      id: 1
+      iweight: 1
+      last_time_change: 123
+      name: server1
       operational_state: up
       port: 80
-      server_id: 1
-      server_name: web_server
+      srvrecord: _myservice._tcp.example.local
+      use_ssl: false
+      uweight: 1
     properties:
       address:
         pattern: ^[^\s]+$
@@ -9747,9 +9766,73 @@ definitions:
           - maint
           - drain
         type: string
+      agent_addr:
+        readOnly: true
+        type: string
+      agent_port:
+        maximum: 65535
+        minimum: 1
+        readOnly: true
+        type: integer
+        x-nullable: true
+      agent_state:
+        readOnly: true
+        type: integer
+        x-nullable: true
+      backend_forced_id:
+        readOnly: true
+        type: integer
+        x-nullable: true
+      backend_id:
+        readOnly: true
+        type: integer
+        x-nullable: true
+      backend_name:
+        readOnly: true
+        type: string
+      check_addr:
+        readOnly: true
+        type: string
+      check_health:
+        readOnly: true
+        type: integer
+        x-nullable: true
+      check_port:
+        maximum: 65535
+        minimum: 1
+        readOnly: true
+        type: integer
+        x-nullable: true
+      check_result:
+        readOnly: true
+        type: integer
+        x-nullable: true
+      check_state:
+        readOnly: true
+        type: integer
+        x-nullable: true
+      check_status:
+        readOnly: true
+        type: integer
+        x-nullable: true
+      foreced_id:
+        readOnly: true
+        type: integer
+        x-nullable: true
+      fqdn:
+        readOnly: true
+        type: string
       id:
         readOnly: true
         type: string
+      iweight:
+        readOnly: true
+        type: integer
+        x-nullable: true
+      last_time_change:
+        readOnly: true
+        type: integer
+        x-nullable: true
       name:
         readOnly: true
         type: string
@@ -9765,6 +9848,16 @@ definitions:
         readOnly: true
         type: integer
         x-nullable: true
+      srvrecord:
+        readOnly: true
+        type: string
+      use_ssl:
+        readOnly: true
+        type: boolean
+      uweight:
+        readOnly: true
+        type: integer
+        x-nullable: true
     title: Runtime Server
     type: object
   runtime_servers:
diff --git a/specification/models/runtime/server.yaml b/specification/models/runtime/server.yaml
index 4950a5c6..a96b1ef4 100644
--- a/specification/models/runtime/server.yaml
+++ b/specification/models/runtime/server.yaml
@@ -4,6 +4,13 @@ server:
   description: Runtime transient server properties
   type: object
   properties:
+    backend_id:
+      type: integer
+      x-nullable: true
+      readOnly: true
+    backend_name:
+      type: string
+      readOnly: true
     id:
       type: string
       readOnly: true
@@ -15,25 +22,111 @@ server:
       pattern: '^[^\s]+$'
       x-nullable: false
       readOnly: true
+    operational_state:
+      type: string
+      enum: [up, down, stopping]
+    admin_state:
+      type: string
+      enum: [ready, maint, drain]
+    uweight:
+      type: integer
+      x-nullable: true
+      readOnly: true
+    iweight:
+      type: integer
+      x-nullable: true
+      readOnly: true
+    last_time_change:
+      type: integer
+      x-nullable: true
+      readOnly: true
+    check_status:
+      type: integer
+      x-nullable: true
+      readOnly: true
+    check_result:
+      type: integer
+      x-nullable: true
+      readOnly: true
+    check_health:
+      type: integer
+      x-nullable: true
+      readOnly: true
+    check_state:
+      type: integer
+      x-nullable: true
+      readOnly: true
+    agent_state:
+      type: integer
+      x-nullable: true
+      readOnly: true
+    backend_forced_id:
+      type: integer
+      x-nullable: true
+      readOnly: true
+    foreced_id:
+      type: integer
+      x-nullable: true
+      readOnly: true
+    fqdn:
+      type: string
+      readOnly: true
     port:
       type: integer
       x-nullable: true
       minimum: 1
       maximum: 65535
       readOnly: true
-    operational_state:
+    srvrecord:
       type: string
-      enum: [up, down, stopping]
-    admin_state:
+      readOnly: true
+    use_ssl:
+      type: boolean
+      readOnly: true
+    check_port:
+      type: integer
+      x-nullable: true
+      minimum: 1
+      maximum: 65535
+      readOnly: true
+    check_addr:
       type: string
-      enum: [ready, maint, drain]
+      readOnly: true
+    agent_addr:
+      type: string
+      readOnly: true
+    agent_port:
+      type: integer
+      x-nullable: true
+      minimum: 1
+      maximum: 65535
+      readOnly: true
   example:
-    server_id: 1
-    server_name: web_server
-    address: 127.0.0.5
-    port: 80
+    backend_id: 2
+    backend_name: myservers
+    id: 1
+    name: server1
+    address: 142.250.191.142
     operational_state: up
     admin_state: ready
+    uweight: 1
+    iweight: 1
+    last_time_change: 123
+    check_status: 17
+    check_result: 2
+    check_health: 0
+    check_state: 6
+    agent_state: 0
+    backend_forced_id: 0
+    forced_id: 0
+    fqdn: server.com
+    port: 80
+    srvrecord: _myservice._tcp.example.local
+    use_ssl: false
+    check_port: 80
+    check_addr: 142.250.191.143
+    agent_addr: 127.0.0.1
+    agent_port: 80
 add_server:
   title: Runtime Add Server
   description: Settable properties when adding a new server using HAProxy's runtime.