chore(models): common Server & Servers for all providers (#943)

internal/provider/cyberghost/filter.go

@@ -11,7 +11,7 @@ import (
 var ErrGroupMismatchesProtocol = errors.New("server group does not match protocol")
 
 func (c *Cyberghost) filterServers(selection settings.ServerSelection) (
-	servers []models.CyberghostServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range c.servers {
 		switch {
 		case

internal/provider/cyberghost/filter_test.go

@@ -16,9 +16,9 @@ func boolPtr(b bool) *bool { return &b }
 func Test_Cyberghost_filterServers(t *testing.T) {
 	t.Parallel()
 	testCases := map[string]struct {
-		servers         []models.CyberghostServer
+		servers         []models.Server
 		selection       settings.ServerSelection
-		filteredServers []models.CyberghostServer
+		filteredServers []models.Server
 		err             error
 	}{
 		"no server": {
@@ -26,20 +26,20 @@ func Test_Cyberghost_filterServers(t *testing.T) {
 			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"servers without filter defaults to UDP": {
-			servers: []models.CyberghostServer{
+			servers: []models.Server{
 				{Country: "a", TCP: true},
 				{Country: "b", TCP: true},
 				{Country: "c", UDP: true},
 				{Country: "d", UDP: true},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Cyberghost),
-			filteredServers: []models.CyberghostServer{
+			filteredServers: []models.Server{
 				{Country: "c", UDP: true},
 				{Country: "d", UDP: true},
 			},
 		},
 		"servers with TCP selection": {
-			servers: []models.CyberghostServer{
+			servers: []models.Server{
 				{Country: "a", TCP: true},
 				{Country: "b", TCP: true},
 				{Country: "c", UDP: true},
@@ -50,13 +50,13 @@ func Test_Cyberghost_filterServers(t *testing.T) {
 					TCP: boolPtr(true),
 				},
 			}.WithDefaults(providers.Cyberghost),
-			filteredServers: []models.CyberghostServer{
+			filteredServers: []models.Server{
 				{Country: "a", TCP: true},
 				{Country: "b", TCP: true},
 			},
 		},
 		"servers with regions filter": {
-			servers: []models.CyberghostServer{
+			servers: []models.Server{
 				{Country: "a", UDP: true},
 				{Country: "b", UDP: true},
 				{Country: "c", UDP: true},
@@ -65,13 +65,13 @@ func Test_Cyberghost_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Countries: []string{"a", "c"},
 			}.WithDefaults(providers.Cyberghost),
-			filteredServers: []models.CyberghostServer{
+			filteredServers: []models.Server{
 				{Country: "a", UDP: true},
 				{Country: "c", UDP: true},
 			},
 		},
 		"servers with hostnames filter": {
-			servers: []models.CyberghostServer{
+			servers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true},
 				{Hostname: "c", UDP: true},
@@ -79,7 +79,7 @@ func Test_Cyberghost_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"a", "c"},
 			}.WithDefaults(providers.Cyberghost),
-			filteredServers: []models.CyberghostServer{
+			filteredServers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "c", UDP: true},
 			},

internal/provider/cyberghost/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Cyberghost struct {
-	servers    []models.CyberghostServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.CyberghostServer, randSource rand.Source) *Cyberghost {
+func New(servers []models.Server, randSource rand.Source) *Cyberghost {
 	return &Cyberghost{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/expressvpn/connection_test.go

@@ -18,7 +18,7 @@ func Test_Provider_GetConnection(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		servers    []models.ExpressvpnServer
+		servers    []models.Server
 		selection  settings.ServerSelection
 		connection models.Connection
 		err        error
@@ -28,7 +28,7 @@ func Test_Provider_GetConnection(t *testing.T) {
 			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"no filter": {
-			servers: []models.ExpressvpnServer{
+			servers: []models.Server{
 				{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
 				{IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
 				{IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},
@@ -45,7 +45,7 @@ func Test_Provider_GetConnection(t *testing.T) {
 			selection: settings.ServerSelection{
 				TargetIP: net.IPv4(2, 2, 2, 2),
 			}.WithDefaults(providers.Expressvpn),
-			servers: []models.ExpressvpnServer{
+			servers: []models.Server{
 				{IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
 				{IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
 				{IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},
@@ -61,7 +61,7 @@ func Test_Provider_GetConnection(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Expressvpn),
-			servers: []models.ExpressvpnServer{
+			servers: []models.Server{
 				{Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
 				{Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
 				{Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},

internal/provider/expressvpn/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (p *Provider) filterServers(selection settings.ServerSelection) (
-	servers []models.ExpressvpnServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range p.servers {
 		switch {
 		case

internal/provider/expressvpn/filter_test.go

@@ -18,9 +18,9 @@ func Test_Expressvpn_filterServers(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		servers   []models.ExpressvpnServer
+		servers   []models.Server
 		selection settings.ServerSelection
-		filtered  []models.ExpressvpnServer
+		filtered  []models.Server
 		err       error
 	}{
 		"no server available": {
@@ -28,13 +28,13 @@ func Test_Expressvpn_filterServers(t *testing.T) {
 			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"no filter": {
-			servers: []models.ExpressvpnServer{
+			servers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true},
 				{Hostname: "c", UDP: true},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Expressvpn),
-			filtered: []models.ExpressvpnServer{
+			filtered: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true},
 				{Hostname: "c", UDP: true},
@@ -44,12 +44,12 @@ func Test_Expressvpn_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Countries: []string{"b"},
 			}.WithDefaults(providers.Expressvpn),
-			servers: []models.ExpressvpnServer{
+			servers: []models.Server{
 				{Country: "a", UDP: true},
 				{Country: "b", UDP: true},
 				{Country: "c", UDP: true},
 			},
-			filtered: []models.ExpressvpnServer{
+			filtered: []models.Server{
 				{Country: "b", UDP: true},
 			},
 		},
@@ -57,12 +57,12 @@ func Test_Expressvpn_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Cities: []string{"b"},
 			}.WithDefaults(providers.Expressvpn),
-			servers: []models.ExpressvpnServer{
+			servers: []models.Server{
 				{City: "a", UDP: true},
 				{City: "b", UDP: true},
 				{City: "c", UDP: true},
 			},
-			filtered: []models.ExpressvpnServer{
+			filtered: []models.Server{
 				{City: "b", UDP: true},
 			},
 		},
@@ -70,12 +70,12 @@ func Test_Expressvpn_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Expressvpn),
-			servers: []models.ExpressvpnServer{
+			servers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true},
 				{Hostname: "c", UDP: true},
 			},
-			filtered: []models.ExpressvpnServer{
+			filtered: []models.Server{
 				{Hostname: "b", UDP: true},
 			},
 		},
@@ -85,12 +85,12 @@ func Test_Expressvpn_filterServers(t *testing.T) {
 					TCP: boolPtr(true),
 				},
 			}.WithDefaults(providers.Expressvpn),
-			servers: []models.ExpressvpnServer{
+			servers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true, TCP: true},
 				{Hostname: "c", UDP: true},
 			},
-			filtered: []models.ExpressvpnServer{
+			filtered: []models.Server{
 				{Hostname: "b", UDP: true, TCP: true},
 			},
 		},

internal/provider/expressvpn/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Provider struct {
-	servers    []models.ExpressvpnServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.ExpressvpnServer, randSource rand.Source) *Provider {
+func New(servers []models.Server, randSource rand.Source) *Provider {
 	return &Provider{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/fastestvpn/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (f *Fastestvpn) filterServers(selection settings.ServerSelection) (
-	servers []models.FastestvpnServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range f.servers {
 		switch {
 		case

internal/provider/fastestvpn/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Fastestvpn struct {
-	servers    []models.FastestvpnServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.FastestvpnServer, randSource rand.Source) *Fastestvpn {
+func New(servers []models.Server, randSource rand.Source) *Fastestvpn {
 	return &Fastestvpn{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/hidemyass/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (h *HideMyAss) filterServers(selection settings.ServerSelection) (
-	servers []models.HideMyAssServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range h.servers {
 		switch {
 		case

internal/provider/hidemyass/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type HideMyAss struct {
-	servers    []models.HideMyAssServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.HideMyAssServer, randSource rand.Source) *HideMyAss {
+func New(servers []models.Server, randSource rand.Source) *HideMyAss {
 	return &HideMyAss{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/ipvanish/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (i *Ipvanish) filterServers(selection settings.ServerSelection) (
-	servers []models.IpvanishServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range i.servers {
 		switch {
 		case

internal/provider/ipvanish/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Ipvanish struct {
-	servers    []models.IpvanishServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.IpvanishServer, randSource rand.Source) *Ipvanish {
+func New(servers []models.Server, randSource rand.Source) *Ipvanish {
 	return &Ipvanish{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/ivpn/connection_test.go

@@ -18,7 +18,7 @@ func Test_Ivpn_GetConnection(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		servers    []models.IvpnServer
+		servers    []models.Server
 		selection  settings.ServerSelection
 		connection models.Connection
 		err        error
@@ -28,7 +28,7 @@ func Test_Ivpn_GetConnection(t *testing.T) {
 			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"no filter": {
-			servers: []models.IvpnServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},
@@ -45,7 +45,7 @@ func Test_Ivpn_GetConnection(t *testing.T) {
 			selection: settings.ServerSelection{
 				TargetIP: net.IPv4(2, 2, 2, 2),
 			}.WithDefaults(providers.Ivpn),
-			servers: []models.IvpnServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},
@@ -61,7 +61,7 @@ func Test_Ivpn_GetConnection(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Ivpn),
-			servers: []models.IvpnServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}, UDP: true},
 				{VPN: constants.OpenVPN, Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}, UDP: true},
 				{VPN: constants.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}, UDP: true},

internal/provider/ivpn/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (i *Ivpn) filterServers(selection settings.ServerSelection) (
-	servers []models.IvpnServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range i.servers {
 		switch {
 		case

internal/provider/ivpn/filter_test.go

@@ -19,9 +19,9 @@ func Test_Ivpn_filterServers(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		servers   []models.IvpnServer
+		servers   []models.Server
 		selection settings.ServerSelection
-		filtered  []models.IvpnServer
+		filtered  []models.Server
 		err       error
 	}{
 		"no server available": {
@@ -29,13 +29,13 @@ func Test_Ivpn_filterServers(t *testing.T) {
 			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"no filter": {
-			servers: []models.IvpnServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a", UDP: true},
 				{VPN: constants.OpenVPN, Hostname: "b", UDP: true},
 				{VPN: constants.OpenVPN, Hostname: "c", UDP: true},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Ivpn),
-			filtered: []models.IvpnServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a", UDP: true},
 				{VPN: constants.OpenVPN, Hostname: "b", UDP: true},
 				{VPN: constants.OpenVPN, Hostname: "c", UDP: true},
@@ -45,12 +45,12 @@ func Test_Ivpn_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Countries: []string{"b"},
 			}.WithDefaults(providers.Ivpn),
-			servers: []models.IvpnServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Country: "a", UDP: true},
 				{VPN: constants.OpenVPN, Country: "b", UDP: true},
 				{VPN: constants.OpenVPN, Country: "c", UDP: true},
 			},
-			filtered: []models.IvpnServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, Country: "b", UDP: true},
 			},
 		},
@@ -58,12 +58,12 @@ func Test_Ivpn_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Cities: []string{"b"},
 			}.WithDefaults(providers.Ivpn),
-			servers: []models.IvpnServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, City: "a", UDP: true},
 				{VPN: constants.OpenVPN, City: "b", UDP: true},
 				{VPN: constants.OpenVPN, City: "c", UDP: true},
 			},
-			filtered: []models.IvpnServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, City: "b", UDP: true},
 			},
 		},
@@ -71,12 +71,12 @@ func Test_Ivpn_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				ISPs: []string{"b"},
 			}.WithDefaults(providers.Ivpn),
-			servers: []models.IvpnServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, ISP: "a", UDP: true},
 				{VPN: constants.OpenVPN, ISP: "b", UDP: true},
 				{VPN: constants.OpenVPN, ISP: "c", UDP: true},
 			},
-			filtered: []models.IvpnServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, ISP: "b", UDP: true},
 			},
 		},
@@ -84,12 +84,12 @@ func Test_Ivpn_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Ivpn),
-			servers: []models.IvpnServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a", UDP: true},
 				{VPN: constants.OpenVPN, Hostname: "b", UDP: true},
 				{VPN: constants.OpenVPN, Hostname: "c", UDP: true},
 			},
-			filtered: []models.IvpnServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "b", UDP: true},
 			},
 		},
@@ -99,12 +99,12 @@ func Test_Ivpn_filterServers(t *testing.T) {
 					TCP: boolPtr(true),
 				},
 			}.WithDefaults(providers.Ivpn),
-			servers: []models.IvpnServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a", UDP: true},
 				{VPN: constants.OpenVPN, Hostname: "b", UDP: true, TCP: true},
 				{VPN: constants.OpenVPN, Hostname: "c", UDP: true},
 			},
-			filtered: []models.IvpnServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "b", UDP: true, TCP: true},
 			},
 		},

internal/provider/ivpn/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Ivpn struct {
-	servers    []models.IvpnServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.IvpnServer, randSource rand.Source) *Ivpn {
+func New(servers []models.Server, randSource rand.Source) *Ivpn {
 	return &Ivpn{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/mullvad/connection_test.go

@@ -18,7 +18,7 @@ func Test_Mullvad_GetConnection(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		servers    []models.MullvadServer
+		servers    []models.Server
 		selection  settings.ServerSelection
 		connection models.Connection
 		err        error
@@ -28,7 +28,7 @@ func Test_Mullvad_GetConnection(t *testing.T) {
 			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"no filter": {
-			servers: []models.MullvadServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
@@ -45,7 +45,7 @@ func Test_Mullvad_GetConnection(t *testing.T) {
 			selection: settings.ServerSelection{
 				TargetIP: net.IPv4(2, 2, 2, 2),
 			}.WithDefaults(providers.Mullvad),
-			servers: []models.MullvadServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
@@ -61,7 +61,7 @@ func Test_Mullvad_GetConnection(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Mullvad),
-			servers: []models.MullvadServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
 				{VPN: constants.OpenVPN, Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
 				{VPN: constants.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},

internal/provider/mullvad/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (m *Mullvad) filterServers(selection settings.ServerSelection) (
-	servers []models.MullvadServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range m.servers {
 		switch {
 		case

internal/provider/mullvad/filter_test.go

@@ -19,9 +19,9 @@ func Test_Mullvad_filterServers(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		servers   []models.MullvadServer
+		servers   []models.Server
 		selection settings.ServerSelection
-		filtered  []models.MullvadServer
+		filtered  []models.Server
 		err       error
 	}{
 		"no server available": {
@@ -29,13 +29,13 @@ func Test_Mullvad_filterServers(t *testing.T) {
 			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"no filter": {
-			servers: []models.MullvadServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a"},
 				{VPN: constants.OpenVPN, Hostname: "b"},
 				{VPN: constants.OpenVPN, Hostname: "c"},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Mullvad),
-			filtered: []models.MullvadServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a"},
 				{VPN: constants.OpenVPN, Hostname: "b"},
 				{VPN: constants.OpenVPN, Hostname: "c"},
@@ -45,12 +45,12 @@ func Test_Mullvad_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				VPN: constants.Wireguard,
 			}.WithDefaults(providers.Mullvad),
-			servers: []models.MullvadServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a"},
 				{VPN: constants.Wireguard, Hostname: "b"},
 				{VPN: constants.OpenVPN, Hostname: "c"},
 			},
-			filtered: []models.MullvadServer{
+			filtered: []models.Server{
 				{VPN: constants.Wireguard, Hostname: "b"},
 			},
 		},
@@ -58,12 +58,12 @@ func Test_Mullvad_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Countries: []string{"b"},
 			}.WithDefaults(providers.Mullvad),
-			servers: []models.MullvadServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Country: "a"},
 				{VPN: constants.OpenVPN, Country: "b"},
 				{VPN: constants.OpenVPN, Country: "c"},
 			},
-			filtered: []models.MullvadServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, Country: "b"},
 			},
 		},
@@ -71,12 +71,12 @@ func Test_Mullvad_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Cities: []string{"b"},
 			}.WithDefaults(providers.Mullvad),
-			servers: []models.MullvadServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, City: "a"},
 				{VPN: constants.OpenVPN, City: "b"},
 				{VPN: constants.OpenVPN, City: "c"},
 			},
-			filtered: []models.MullvadServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, City: "b"},
 			},
 		},
@@ -84,12 +84,12 @@ func Test_Mullvad_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				ISPs: []string{"b"},
 			}.WithDefaults(providers.Mullvad),
-			servers: []models.MullvadServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, ISP: "a"},
 				{VPN: constants.OpenVPN, ISP: "b"},
 				{VPN: constants.OpenVPN, ISP: "c"},
 			},
-			filtered: []models.MullvadServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, ISP: "b"},
 			},
 		},
@@ -97,12 +97,12 @@ func Test_Mullvad_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Mullvad),
-			servers: []models.MullvadServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a"},
 				{VPN: constants.OpenVPN, Hostname: "b"},
 				{VPN: constants.OpenVPN, Hostname: "c"},
 			},
-			filtered: []models.MullvadServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "b"},
 			},
 		},
@@ -110,12 +110,12 @@ func Test_Mullvad_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				OwnedOnly: boolPtr(true),
 			}.WithDefaults(providers.Mullvad),
-			servers: []models.MullvadServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a"},
 				{VPN: constants.OpenVPN, Hostname: "b", Owned: true},
 				{VPN: constants.OpenVPN, Hostname: "c"},
 			},
-			filtered: []models.MullvadServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "b", Owned: true},
 			},
 		},

internal/provider/mullvad/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Mullvad struct {
-	servers    []models.MullvadServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.MullvadServer, randSource rand.Source) *Mullvad {
+func New(servers []models.Server, randSource rand.Source) *Mullvad {
 	return &Mullvad{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/nordvpn/filter.go

@@ -9,7 +9,7 @@ import (
 )
 
 func (n *Nordvpn) filterServers(selection settings.ServerSelection) (
-	servers []models.NordvpnServer, err error) {
+	servers []models.Server, err error) {
 	selectedNumbers := make([]string, len(selection.Numbers))
 	for i := range selection.Numbers {
 		selectedNumbers[i] = strconv.Itoa(int(selection.Numbers[i]))

internal/provider/nordvpn/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Nordvpn struct {
-	servers    []models.NordvpnServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.NordvpnServer, randSource rand.Source) *Nordvpn {
+func New(servers []models.Server, randSource rand.Source) *Nordvpn {
 	return &Nordvpn{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/perfectprivacy/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (p *Perfectprivacy) filterServers(selection settings.ServerSelection) (
-	servers []models.PerfectprivacyServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range p.servers {
 		switch {
 		case

internal/provider/perfectprivacy/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Perfectprivacy struct {
-	servers    []models.PerfectprivacyServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.PerfectprivacyServer, randSource rand.Source) *Perfectprivacy {
+func New(servers []models.Server, randSource rand.Source) *Perfectprivacy {
 	return &Perfectprivacy{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/privado/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (p *Privado) filterServers(selection settings.ServerSelection) (
-	servers []models.PrivadoServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range p.servers {
 		switch {
 		case

internal/provider/privado/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Privado struct {
-	servers    []models.PrivadoServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.PrivadoServer, randSource rand.Source) *Privado {
+func New(servers []models.Server, randSource rand.Source) *Privado {
 	return &Privado{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/privateinternetaccess/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (p *PIA) filterServers(selection settings.ServerSelection) (
-	servers []models.PIAServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range p.servers {
 		switch {
 		case

internal/provider/privateinternetaccess/portforward.go

@@ -29,7 +29,7 @@ var (
 func (p *PIA) PortForward(ctx context.Context, client *http.Client,
 	logger utils.Logger, gateway net.IP, serverName string) (
 	port uint16, err error) {
-	var server models.PIAServer
+	var server models.Server
 	for _, server = range p.servers {
 		if server.ServerName == serverName {
 			break

internal/provider/privateinternetaccess/provider.go

@@ -9,7 +9,7 @@ import (
 )
 
 type PIA struct {
-	servers    []models.PIAServer
+	servers    []models.Server
 	randSource rand.Source
 	timeNow    func() time.Time
 	// Port forwarding
@@ -17,7 +17,7 @@ type PIA struct {
 	authFilePath    string
 }
 
-func New(servers []models.PIAServer, randSource rand.Source,
+func New(servers []models.Server, randSource rand.Source,
 	timeNow func() time.Time) *PIA {
 	const jsonPortForwardPath = "/gluetun/piaportforward.json"
 	return &PIA{

internal/provider/privatevpn/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (p *Privatevpn) filterServers(selection settings.ServerSelection) (
-	servers []models.PrivatevpnServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range p.servers {
 		switch {
 		case

internal/provider/privatevpn/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Privatevpn struct {
-	servers    []models.PrivatevpnServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.PrivatevpnServer, randSource rand.Source) *Privatevpn {
+func New(servers []models.Server, randSource rand.Source) *Privatevpn {
 	return &Privatevpn{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/protonvpn/filter.go

@@ -9,7 +9,7 @@ import (
 )
 
 func (p *Protonvpn) filterServers(selection settings.ServerSelection) (
-	servers []models.ProtonvpnServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range p.servers {
 		switch {
 		case
@@ -17,8 +17,8 @@ func (p *Protonvpn) filterServers(selection settings.ServerSelection) (
 			utils.FilterByPossibilities(server.Region, selection.Regions),
 			utils.FilterByPossibilities(server.City, selection.Cities),
 			utils.FilterByPossibilities(server.Hostname, selection.Hostnames),
-			utils.FilterByPossibilities(server.Name, selection.Names),
-			*selection.FreeOnly && !strings.Contains(strings.ToLower(server.Name), "free"):
+			utils.FilterByPossibilities(server.ServerName, selection.Names),
+			*selection.FreeOnly && !strings.Contains(strings.ToLower(server.ServerName), "free"):
 		default:
 			servers = append(servers, server)
 		}

internal/provider/protonvpn/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Protonvpn struct {
-	servers    []models.ProtonvpnServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.ProtonvpnServer, randSource rand.Source) *Protonvpn {
+func New(servers []models.Server, randSource rand.Source) *Protonvpn {
 	return &Protonvpn{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/purevpn/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (p *Purevpn) filterServers(selection settings.ServerSelection) (
-	servers []models.PurevpnServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range p.servers {
 		switch {
 		case

internal/provider/purevpn/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Purevpn struct {
-	servers    []models.PurevpnServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.PurevpnServer, randSource rand.Source) *Purevpn {
+func New(servers []models.Server, randSource rand.Source) *Purevpn {
 	return &Purevpn{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/surfshark/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (s *Surfshark) filterServers(selection settings.ServerSelection) (
-	servers []models.SurfsharkServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range s.servers {
 		switch {
 		case

internal/provider/surfshark/filter_test.go

@@ -18,9 +18,9 @@ func Test_Surfshark_filterServers(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		servers   []models.SurfsharkServer
+		servers   []models.Server
 		selection settings.ServerSelection
-		filtered  []models.SurfsharkServer
+		filtered  []models.Server
 		err       error
 	}{
 		"no server available": {
@@ -28,13 +28,13 @@ func Test_Surfshark_filterServers(t *testing.T) {
 			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"no filter": {
-			servers: []models.SurfsharkServer{
+			servers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true},
 				{Hostname: "c", UDP: true},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Surfshark),
-			filtered: []models.SurfsharkServer{
+			filtered: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true},
 				{Hostname: "c", UDP: true},
@@ -44,12 +44,12 @@ func Test_Surfshark_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Regions: []string{"b"},
 			}.WithDefaults(providers.Surfshark),
-			servers: []models.SurfsharkServer{
+			servers: []models.Server{
 				{Region: "a", UDP: true},
 				{Region: "b", UDP: true},
 				{Region: "c", UDP: true},
 			},
-			filtered: []models.SurfsharkServer{
+			filtered: []models.Server{
 				{Region: "b", UDP: true},
 			},
 		},
@@ -57,12 +57,12 @@ func Test_Surfshark_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Countries: []string{"b"},
 			}.WithDefaults(providers.Surfshark),
-			servers: []models.SurfsharkServer{
+			servers: []models.Server{
 				{Country: "a", UDP: true},
 				{Country: "b", UDP: true},
 				{Country: "c", UDP: true},
 			},
-			filtered: []models.SurfsharkServer{
+			filtered: []models.Server{
 				{Country: "b", UDP: true},
 			},
 		},
@@ -70,12 +70,12 @@ func Test_Surfshark_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Cities: []string{"b"},
 			}.WithDefaults(providers.Surfshark),
-			servers: []models.SurfsharkServer{
+			servers: []models.Server{
 				{City: "a", UDP: true},
 				{City: "b", UDP: true},
 				{City: "c", UDP: true},
 			},
-			filtered: []models.SurfsharkServer{
+			filtered: []models.Server{
 				{City: "b", UDP: true},
 			},
 		},
@@ -83,12 +83,12 @@ func Test_Surfshark_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Surfshark),
-			servers: []models.SurfsharkServer{
+			servers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true},
 				{Hostname: "c", UDP: true},
 			},
-			filtered: []models.SurfsharkServer{
+			filtered: []models.Server{
 				{Hostname: "b", UDP: true},
 			},
 		},
@@ -98,12 +98,12 @@ func Test_Surfshark_filterServers(t *testing.T) {
 					TCP: boolPtr(true),
 				},
 			}.WithDefaults(providers.Surfshark),
-			servers: []models.SurfsharkServer{
+			servers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true, TCP: true},
 				{Hostname: "c", UDP: true},
 			},
-			filtered: []models.SurfsharkServer{
+			filtered: []models.Server{
 				{Hostname: "b", UDP: true, TCP: true},
 			},
 		},
@@ -111,12 +111,12 @@ func Test_Surfshark_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				MultiHopOnly: boolPtr(true),
 			}.WithDefaults(providers.Surfshark),
-			servers: []models.SurfsharkServer{
+			servers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", MultiHop: true, UDP: true},
 				{Hostname: "c", UDP: true},
 			},
-			filtered: []models.SurfsharkServer{
+			filtered: []models.Server{
 				{Hostname: "b", MultiHop: true, UDP: true},
 			},
 		},

internal/provider/surfshark/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Surfshark struct {
-	servers    []models.SurfsharkServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.SurfsharkServer, randSource rand.Source) *Surfshark {
+func New(servers []models.Server, randSource rand.Source) *Surfshark {
 	return &Surfshark{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/torguard/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (t *Torguard) filterServers(selection settings.ServerSelection) (
-	servers []models.TorguardServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range t.servers {
 		switch {
 		case

internal/provider/torguard/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Torguard struct {
-	servers    []models.TorguardServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.TorguardServer, randSource rand.Source) *Torguard {
+func New(servers []models.Server, randSource rand.Source) *Torguard {
 	return &Torguard{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/vpnunlimited/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (p *Provider) filterServers(selection settings.ServerSelection) (
-	servers []models.VPNUnlimitedServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range p.servers {
 		switch {
 		case

internal/provider/vpnunlimited/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Provider struct {
-	servers    []models.VPNUnlimitedServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.VPNUnlimitedServer, randSource rand.Source) *Provider {
+func New(servers []models.Server, randSource rand.Source) *Provider {
 	return &Provider{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/vyprvpn/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (v *Vyprvpn) filterServers(selection settings.ServerSelection) (
-	servers []models.VyprvpnServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range v.servers {
 		switch {
 		case

internal/provider/vyprvpn/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Vyprvpn struct {
-	servers    []models.VyprvpnServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.VyprvpnServer, randSource rand.Source) *Vyprvpn {
+func New(servers []models.Server, randSource rand.Source) *Vyprvpn {
 	return &Vyprvpn{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/wevpn/connection_test.go

@@ -18,7 +18,7 @@ func Test_Wevpn_GetConnection(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		servers    []models.WevpnServer
+		servers    []models.Server
 		selection  settings.ServerSelection
 		connection models.Connection
 		err        error
@@ -30,7 +30,7 @@ func Test_Wevpn_GetConnection(t *testing.T) {
 			err: errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"no filter": {
-			servers: []models.WevpnServer{
+			servers: []models.Server{
 				{UDP: true, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
 				{UDP: true, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
 				{UDP: true, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
@@ -47,7 +47,7 @@ func Test_Wevpn_GetConnection(t *testing.T) {
 			selection: settings.ServerSelection{
 				TargetIP: net.IPv4(2, 2, 2, 2),
 			}.WithDefaults(providers.Wevpn),
-			servers: []models.WevpnServer{
+			servers: []models.Server{
 				{UDP: true, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
 				{UDP: true, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
 				{UDP: true, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
@@ -63,7 +63,7 @@ func Test_Wevpn_GetConnection(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Wevpn),
-			servers: []models.WevpnServer{
+			servers: []models.Server{
 				{UDP: true, Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
 				{UDP: true, Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
 				{UDP: true, Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},

internal/provider/wevpn/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (w *Wevpn) filterServers(selection settings.ServerSelection) (
-	servers []models.WevpnServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range w.servers {
 		switch {
 		case

internal/provider/wevpn/filter_test.go

@@ -18,9 +18,9 @@ func Test_Wevpn_filterServers(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		servers   []models.WevpnServer
+		servers   []models.Server
 		selection settings.ServerSelection
-		filtered  []models.WevpnServer
+		filtered  []models.Server
 		err       error
 	}{
 		"no server available": {
@@ -28,13 +28,13 @@ func Test_Wevpn_filterServers(t *testing.T) {
 			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"no filter": {
-			servers: []models.WevpnServer{
+			servers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true},
 				{Hostname: "c", UDP: true},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Wevpn),
-			filtered: []models.WevpnServer{
+			filtered: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true},
 				{Hostname: "c", UDP: true},
@@ -44,12 +44,12 @@ func Test_Wevpn_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				OpenVPN: settings.OpenVPNSelection{TCP: boolPtr(true)},
 			}.WithDefaults(providers.Wevpn),
-			servers: []models.WevpnServer{
+			servers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", TCP: true},
 				{Hostname: "c", UDP: true},
 			},
-			filtered: []models.WevpnServer{
+			filtered: []models.Server{
 				{Hostname: "b", TCP: true},
 			},
 		},
@@ -57,12 +57,12 @@ func Test_Wevpn_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Cities: []string{"b"},
 			}.WithDefaults(providers.Wevpn),
-			servers: []models.WevpnServer{
+			servers: []models.Server{
 				{City: "a", UDP: true},
 				{City: "b", UDP: true},
 				{City: "c", UDP: true},
 			},
-			filtered: []models.WevpnServer{
+			filtered: []models.Server{
 				{City: "b", UDP: true},
 			},
 		},
@@ -70,12 +70,12 @@ func Test_Wevpn_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Wevpn),
-			servers: []models.WevpnServer{
+			servers: []models.Server{
 				{Hostname: "a", UDP: true},
 				{Hostname: "b", UDP: true},
 				{Hostname: "c", UDP: true},
 			},
-			filtered: []models.WevpnServer{
+			filtered: []models.Server{
 				{Hostname: "b", UDP: true},
 			},
 		},

internal/provider/wevpn/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Wevpn struct {
-	servers    []models.WevpnServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.WevpnServer, randSource rand.Source) *Wevpn {
+func New(servers []models.Server, randSource rand.Source) *Wevpn {
 	return &Wevpn{
 		servers:         servers,
 		randSource:      randSource,

internal/provider/windscribe/connection_test.go

@@ -18,7 +18,7 @@ func Test_Windscribe_GetConnection(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		servers    []models.WindscribeServer
+		servers    []models.Server
 		selection  settings.ServerSelection
 		connection models.Connection
 		err        error
@@ -28,7 +28,7 @@ func Test_Windscribe_GetConnection(t *testing.T) {
 			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"no filter": {
-			servers: []models.WindscribeServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
@@ -45,7 +45,7 @@ func Test_Windscribe_GetConnection(t *testing.T) {
 			selection: settings.ServerSelection{
 				TargetIP: net.IPv4(2, 2, 2, 2),
 			}.WithDefaults(providers.Windscribe),
-			servers: []models.WindscribeServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
 				{VPN: constants.OpenVPN, IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},
@@ -61,7 +61,7 @@ func Test_Windscribe_GetConnection(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Windscribe),
-			servers: []models.WindscribeServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(1, 1, 1, 1)}},
 				{VPN: constants.OpenVPN, Hostname: "b", IPs: []net.IP{net.IPv4(2, 2, 2, 2)}},
 				{VPN: constants.OpenVPN, Hostname: "a", IPs: []net.IP{net.IPv4(3, 3, 3, 3)}},

internal/provider/windscribe/filter.go

@@ -7,7 +7,7 @@ import (
 )
 
 func (w *Windscribe) filterServers(selection settings.ServerSelection) (
-	servers []models.WindscribeServer, err error) {
+	servers []models.Server, err error) {
 	for _, server := range w.servers {
 		switch {
 		case

internal/provider/windscribe/filter_test.go

@@ -17,9 +17,9 @@ func Test_Windscribe_filterServers(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		servers   []models.WindscribeServer
+		servers   []models.Server
 		selection settings.ServerSelection
-		filtered  []models.WindscribeServer
+		filtered  []models.Server
 		err       error
 	}{
 		"no server available": {
@@ -27,13 +27,13 @@ func Test_Windscribe_filterServers(t *testing.T) {
 			err:       errors.New("no server found: for VPN openvpn; protocol udp"),
 		},
 		"no filter": {
-			servers: []models.WindscribeServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a"},
 				{VPN: constants.OpenVPN, Hostname: "b"},
 				{VPN: constants.OpenVPN, Hostname: "c"},
 			},
 			selection: settings.ServerSelection{}.WithDefaults(providers.Windscribe),
-			filtered: []models.WindscribeServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a"},
 				{VPN: constants.OpenVPN, Hostname: "b"},
 				{VPN: constants.OpenVPN, Hostname: "c"},
@@ -43,12 +43,12 @@ func Test_Windscribe_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				VPN: constants.Wireguard,
 			}.WithDefaults(providers.Windscribe),
-			servers: []models.WindscribeServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a"},
 				{VPN: constants.Wireguard, Hostname: "b"},
 				{VPN: constants.OpenVPN, Hostname: "c"},
 			},
-			filtered: []models.WindscribeServer{
+			filtered: []models.Server{
 				{VPN: constants.Wireguard, Hostname: "b"},
 			},
 		},
@@ -56,12 +56,12 @@ func Test_Windscribe_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Regions: []string{"b"},
 			}.WithDefaults(providers.Windscribe),
-			servers: []models.WindscribeServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Region: "a"},
 				{VPN: constants.OpenVPN, Region: "b"},
 				{VPN: constants.OpenVPN, Region: "c"},
 			},
-			filtered: []models.WindscribeServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, Region: "b"},
 			},
 		},
@@ -69,12 +69,12 @@ func Test_Windscribe_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Cities: []string{"b"},
 			}.WithDefaults(providers.Windscribe),
-			servers: []models.WindscribeServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, City: "a"},
 				{VPN: constants.OpenVPN, City: "b"},
 				{VPN: constants.OpenVPN, City: "c"},
 			},
-			filtered: []models.WindscribeServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, City: "b"},
 			},
 		},
@@ -82,12 +82,12 @@ func Test_Windscribe_filterServers(t *testing.T) {
 			selection: settings.ServerSelection{
 				Hostnames: []string{"b"},
 			}.WithDefaults(providers.Windscribe),
-			servers: []models.WindscribeServer{
+			servers: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "a"},
 				{VPN: constants.OpenVPN, Hostname: "b"},
 				{VPN: constants.OpenVPN, Hostname: "c"},
 			},
-			filtered: []models.WindscribeServer{
+			filtered: []models.Server{
 				{VPN: constants.OpenVPN, Hostname: "b"},
 			},
 		},

internal/provider/windscribe/provider.go

@@ -9,12 +9,12 @@ import (
 )
 
 type Windscribe struct {
-	servers    []models.WindscribeServer
+	servers    []models.Server
 	randSource rand.Source
 	utils.NoPortForwarder
 }
 
-func New(servers []models.WindscribeServer, randSource rand.Source) *Windscribe {
+func New(servers []models.Server, randSource rand.Source) *Windscribe {
 	return &Windscribe{
 		servers:         servers,
 		randSource:      randSource,