Code cleanup

- Refactor `RemoveApiAccessMethod` to be based on UUID
- Remove debug-prints in `mullvad api-access list` et al
- Get rid of `GetApiAccessMethods` RPC
- Use the more generic RPC `GetSettings` to get hold of all API access
methods instead
- Rename `mullvad_types::access_method` to `mullvad_types::api_access`
- Remove (unjustified) `#[inline(always)]` attributes

16 files changed, 96 insertions, 108 deletions

diff --git a/mullvad-api/src/https_client_with_sni.rs b/mullvad-api/src/https_client_with_sni.rs
index cc7557a8d2..e95fbf98fc 100644
--- a/mullvad-api/src/https_client_with_sni.rs
+++ b/mullvad-api/src/https_client_with_sni.rs
@@ -248,12 +248,12 @@ impl TryFrom<ApiConnectionMode> for InnerConnectionMode {
                     })
                 }
                 ProxyConfig::Socks(config) => match config {
-                    mullvad_types::access_method::Socks5::Local(config) => {
+                    mullvad_types::api_access::Socks5::Local(config) => {
                         InnerConnectionMode::Socks5(SocksConfig {
                             peer: SocketAddr::new("127.0.0.1".parse().unwrap(), config.port),
                         })
                     }
-                    mullvad_types::access_method::Socks5::Remote(config) => {
+                    mullvad_types::api_access::Socks5::Remote(config) => {
                         InnerConnectionMode::Socks5(SocksConfig { peer: config.peer })
                     }
                 },
diff --git a/mullvad-api/src/proxy.rs b/mullvad-api/src/proxy.rs
index 44a2309587..7d33840d69 100644
--- a/mullvad-api/src/proxy.rs
+++ b/mullvad-api/src/proxy.rs
@@ -1,6 +1,6 @@
 use futures::Stream;
 use hyper::client::connect::Connected;
-use mullvad_types::access_method;
+use mullvad_types::api_access;
 use serde::{Deserialize, Serialize};
 use std::{
     fmt, io,
@@ -36,8 +36,8 @@ impl fmt::Display for ApiConnectionMode {
 
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub enum ProxyConfig {
-    Shadowsocks(access_method::Shadowsocks),
-    Socks(access_method::Socks5),
+    Shadowsocks(api_access::Shadowsocks),
+    Socks(api_access::Socks5),
 }
 
 impl ProxyConfig {
@@ -46,8 +46,8 @@ impl ProxyConfig {
         match self {
             ProxyConfig::Shadowsocks(ss) => ss.peer,
             ProxyConfig::Socks(socks) => match socks {
-                access_method::Socks5::Local(s) => s.peer,
-                access_method::Socks5::Remote(s) => s.peer,
+                api_access::Socks5::Local(s) => s.peer,
+                api_access::Socks5::Remote(s) => s.peer,
             },
         }
     }
@@ -59,10 +59,10 @@ impl fmt::Display for ProxyConfig {
             // TODO: Do not hardcode TCP
             ProxyConfig::Shadowsocks(ss) => write!(f, "Shadowsocks {}/TCP", ss.peer),
             ProxyConfig::Socks(socks) => match socks {
-                access_method::Socks5::Local(s) => {
+                api_access::Socks5::Local(s) => {
                     write!(f, "Socks5 {}/TCP via localhost:{}", s.peer, s.port)
                 }
-                access_method::Socks5::Remote(s) => write!(f, "Socks5 {}/TCP", s.peer),
+                api_access::Socks5::Remote(s) => write!(f, "Socks5 {}/TCP", s.peer),
             },
         }
     }
diff --git a/mullvad-cli/src/cmds/api_access.rs b/mullvad-cli/src/cmds/api_access.rs
index 7b7656ca6a..ae202055b6 100644
--- a/mullvad-cli/src/cmds/api_access.rs
+++ b/mullvad-cli/src/cmds/api_access.rs
@@ -83,7 +83,7 @@ impl ApiAccess {
     async fn remove(cmd: SelectItem) -> Result<()> {
         let mut rpc = MullvadProxyClient::new().await?;
         let access_method = Self::get_access_method(&mut rpc, &cmd).await?;
-        rpc.remove_access_method(access_method)
+        rpc.remove_access_method(access_method.get_id())
             .await
             .map_err(Into::<anyhow::Error>::into)
     }
@@ -107,27 +107,28 @@ impl ApiAccess {
                 let cipher = cmd.params.cipher.unwrap_or(shadowsocks.cipher);
                 let name = cmd.params.name.unwrap_or(api_access_method.name);
                 let enabled = api_access_method.enabled;
-                mullvad_types::access_method::Shadowsocks::from_args(ip, port, cipher, password)
-                    .map(|shadowsocks| {
+                mullvad_types::api_access::Shadowsocks::from_args(ip, port, cipher, password).map(
+                    |shadowsocks| {
                         ApiAccessMethod::new(name, enabled, AccessMethod::from(shadowsocks))
-                    })
+                    },
+                )
             }
             CustomAccessMethod::Socks5(socks) => match socks {
-                mullvad_types::access_method::Socks5::Local(local) => {
+                mullvad_types::api_access::Socks5::Local(local) => {
                     let ip = cmd.params.ip.unwrap_or(local.peer.ip()).to_string();
                     let port = cmd.params.port.unwrap_or(local.peer.port());
                     let local_port = cmd.params.local_port.unwrap_or(local.port);
                     let name = cmd.params.name.unwrap_or(api_access_method.get_name());
                     let enabled = api_access_method.enabled();
-                    mullvad_types::access_method::Socks5Local::from_args(ip, port, local_port)
+                    mullvad_types::api_access::Socks5Local::from_args(ip, port, local_port)
                         .map(|socks| ApiAccessMethod::new(name, enabled, AccessMethod::from(socks)))
                 }
-                mullvad_types::access_method::Socks5::Remote(remote) => {
+                mullvad_types::api_access::Socks5::Remote(remote) => {
                     let ip = cmd.params.ip.unwrap_or(remote.peer.ip()).to_string();
                     let port = cmd.params.port.unwrap_or(remote.peer.port());
                     let name = cmd.params.name.unwrap_or(api_access_method.get_name());
                     let enabled = api_access_method.enabled();
-                    mullvad_types::access_method::Socks5Remote::from_args(ip, port)
+                    mullvad_types::api_access::Socks5Remote::from_args(ip, port)
                         .map(|socks| ApiAccessMethod::new(name, enabled, AccessMethod::from(socks)))
                 }
             },
@@ -310,7 +311,7 @@ pub struct EditParams {
 /// we define them in a hidden-away module.
 mod conversions {
     use anyhow::{anyhow, Error};
-    use mullvad_types::access_method as daemon_types;
+    use mullvad_types::api_access as daemon_types;
 
     use super::{AddCustomCommands, Socks5AddCommands};
 
@@ -328,7 +329,7 @@ mod conversions {
                         remote_port,
                         name,
                     } => {
-                        println!("Adding LOCAL SOCKS5-proxy: localhost:{local_port} => {remote_ip}:{remote_port}");
+                        println!("Adding Local SOCKS5-proxy: localhost:{local_port} => {remote_ip}:{remote_port}");
                         let socks_proxy = daemon_types::Socks5::Local(
                             daemon_types::Socks5Local::from_args(
                                 remote_ip.to_string(),
@@ -348,7 +349,7 @@ mod conversions {
                         remote_port,
                         name,
                     } => {
-                        println!("Adding REMOTE SOCKS5-proxy: {remote_ip}:{remote_port}");
+                        println!("Adding SOCKS5-proxy: {remote_ip}:{remote_port}");
                         let socks_proxy = daemon_types::Socks5::Remote(
                             daemon_types::Socks5Remote::from_args(
                                 remote_ip.to_string(),
@@ -394,7 +395,7 @@ mod conversions {
 
 /// Pretty printing of [`ApiAccessMethod`]s
 mod pp {
-    use mullvad_types::access_method::{AccessMethod, ApiAccessMethod, CustomAccessMethod, Socks5};
+    use mullvad_types::api_access::{AccessMethod, ApiAccessMethod, CustomAccessMethod, Socks5};
 
     pub struct ApiAccessMethodFormatter<'a> {
         api_access_method: &'a ApiAccessMethod,
@@ -418,9 +419,6 @@ mod pp {
                 }
             };
 
-            // TODO: For debugging purposes only, remove later
-            writeln!(f, "{:?}", self.api_access_method)?;
-
             match &self.api_access_method.access_method {
                 AccessMethod::BuiltIn(method) => {
                     write!(f, "{}", method.canonical_name())?;
diff --git a/mullvad-daemon/src/access_method.rs b/mullvad-daemon/src/access_method.rs
index a44008becd..fa4da174d3 100644
--- a/mullvad-daemon/src/access_method.rs
+++ b/mullvad-daemon/src/access_method.rs
@@ -11,6 +11,9 @@ pub enum Error {
     /// Can not add access method
     #[error(display = "Cannot add custom access method")]
     Add,
+    /// Can not remove built-in access method
+    #[error(display = "Cannot remove built-in access method")]
+    RemoveBuiltIn,
     /// Can not find access method
     #[error(display = "Cannot find custom access method {}", _0)]
     NoSuchMethod(ApiAccessMethodId),
@@ -35,6 +38,17 @@ where
         &mut self,
         access_method: ApiAccessMethodId,
     ) -> Result<(), Error> {
+        // Make sure that we are not trying to remove a built-in API access
+        // method
+        match self.settings.api_access_methods.find(&access_method) {
+            None => return Ok(()),
+            Some(api_access_method) => {
+                if api_access_method.is_builtin() {
+                    return Err(Error::RemoveBuiltIn);
+                }
+            }
+        };
+
         self.settings
             .update(|settings| settings.api_access_methods.remove(&access_method))
             .await
@@ -49,10 +63,7 @@ where
         self.settings
             .update(|settings| {
                 let access_methods = &mut settings.api_access_methods;
-                if let Some(access_method) =
-                    // TODO: This will not work, has to be based on ID!
-                    access_methods.find_mut(&access_method_update.id)
-                {
+                if let Some(access_method) = access_methods.find_mut(&access_method_update.id) {
                     *access_method = access_method_update.access_method
                 }
             })
diff --git a/mullvad-daemon/src/api.rs b/mullvad-daemon/src/api.rs
index e07037edad..5605f567ca 100644
--- a/mullvad-daemon/src/api.rs
+++ b/mullvad-daemon/src/api.rs
@@ -10,7 +10,7 @@ use mullvad_api::{
     ApiEndpointUpdateCallback,
 };
 use mullvad_relay_selector::RelaySelector;
-use mullvad_types::access_method::{self, AccessMethod, BuiltInAccessMethod};
+use mullvad_types::api_access::{self, AccessMethod, BuiltInAccessMethod};
 use std::{
     net::SocketAddr,
     path::PathBuf,
@@ -131,12 +131,11 @@ impl ApiConnectionModeProvider {
                     .get_bridge_forced()
                     .and_then(|settings| match settings {
                         ProxySettings::Shadowsocks(ss_settings) => {
-                            let ss_settings: access_method::Shadowsocks =
-                                access_method::Shadowsocks::new(
-                                    ss_settings.peer,
-                                    ss_settings.cipher,
-                                    ss_settings.password,
-                                );
+                            let ss_settings: api_access::Shadowsocks = api_access::Shadowsocks::new(
+                                ss_settings.peer,
+                                ss_settings.cipher,
+                                ss_settings.password,
+                            );
                             Some(ApiConnectionMode::Proxied(ProxyConfig::Shadowsocks(
                                 ss_settings,
                             )))
@@ -149,10 +148,10 @@ impl ApiConnectionModeProvider {
                     .unwrap_or(ApiConnectionMode::Direct),
             },
             AccessMethod::Custom(access_method) => match &access_method {
-                access_method::CustomAccessMethod::Shadowsocks(shadowsocks_config) => {
+                api_access::CustomAccessMethod::Shadowsocks(shadowsocks_config) => {
                     ApiConnectionMode::Proxied(ProxyConfig::Shadowsocks(shadowsocks_config.clone()))
                 }
-                access_method::CustomAccessMethod::Socks5(socks_config) => {
+                api_access::CustomAccessMethod::Socks5(socks_config) => {
                     ApiConnectionMode::Proxied(ProxyConfig::Socks(socks_config.clone()))
                 }
             },
diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index f8cf6cda28..1fedbfbde2 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -41,6 +41,7 @@ use mullvad_relay_selector::{
 use mullvad_types::{
     access_method::{daemon::ApiAccessMethodUpdate, ApiAccessMethod, ApiAccessMethodId},
     account::{AccountData, AccountToken, VoucherSubmission},
+    api_access::{ApiAccessMethod, ApiAccessMethodId},
     auth_failed::AuthFailed,
     custom_list::CustomList,
     device::{Device, DeviceEvent, DeviceEventCause, DeviceId, DeviceState, RemoveDeviceEvent},
diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index b3a8831ef1..12671a41c7 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -619,27 +619,13 @@ impl ManagementService for ManagementServiceImpl {
             .map_err(map_daemon_error)
     }
 
-    async fn get_api_access_methods(
-        &self,
-        _: Request<()>,
-    ) -> ServiceResult<mullvad_management_interface::types::ApiAccessMethods> {
-        log::debug!("get_api_access_methods");
-        let (tx, rx) = oneshot::channel();
-        self.send_command_to_daemon(DaemonCommand::GetApiAccessMethods(tx))?;
-        self.wait_for_result(rx)
-            .await?
-            .map(From::from)
-            .map(Response::new)
-            .map_err(map_daemon_error)
-    }
-
     async fn add_api_access_method(
         &self,
         request: Request<types::ApiAccessMethod>,
     ) -> ServiceResult<()> {
         log::debug!("add_api_access_method");
         let api_access_method =
-            mullvad_types::access_method::ApiAccessMethod::try_from(request.into_inner())?;
+            mullvad_types::api_access::ApiAccessMethod::try_from(request.into_inner())?;
         let (tx, rx) = oneshot::channel();
         self.send_command_to_daemon(DaemonCommand::AddApiAccessMethod(tx, api_access_method))?;
         self.wait_for_result(rx)
@@ -648,10 +634,7 @@ impl ManagementService for ManagementServiceImpl {
             .map_err(map_daemon_error)
     }
 
-    async fn remove_api_access_method(
-        &self,
-        request: Request<types::ApiAccessMethod>,
-    ) -> ServiceResult<()> {
+    async fn remove_api_access_method(&self, request: Request<types::Uuid>) -> ServiceResult<()> {
         log::debug!("remove_api_access_method");
         let api_access_method =
             mullvad_types::api_access::ApiAccessMethodId::try_from(request.into_inner())?;
diff --git a/mullvad-management-interface/proto/management_interface.proto b/mullvad-management-interface/proto/management_interface.proto
index ad982ea556..667778475a 100644
--- a/mullvad-management-interface/proto/management_interface.proto
+++ b/mullvad-management-interface/proto/management_interface.proto
@@ -22,6 +22,7 @@ service ManagementService {
 
   rpc GetCurrentVersion(google.protobuf.Empty) returns (google.protobuf.StringValue) {}
   rpc GetVersionInfo(google.protobuf.Empty) returns (AppVersionInfo) {}
+  rpc GetApiAddressess(google.protobuf.Empty) returns (google.protobuf.Empty) {}
 
   rpc IsPerformingPostUpgrade(google.protobuf.Empty) returns (google.protobuf.BoolValue) {}
 
@@ -74,21 +75,10 @@ service ManagementService {
   rpc UpdateCustomList(CustomList) returns (google.protobuf.Empty) {}
 
   // API Access methods
-  rpc GetApiAccessMethods(google.protobuf.Empty) returns (ApiAccessMethods) {}
-  rpc AddApiAccessMethod(ApiAccessMethod) returns (google.protobuf.Empty) {
-    // Can I return something useful here instead of Empty?
-  }
-  rpc RemoveApiAccessMethod(ApiAccessMethod) returns (google.protobuf.Empty) {
-    // Can I return something useful here instead of Empty?
-  }
-  rpc UpdateApiAccessMethod(ApiAccessMethodUpdate) returns (google.protobuf.Empty) {
-    // Can I return something useful here instead of Empty?
-  }
-  rpc SetApiAccessMethod(UUID) returns (google.protobuf.Empty) {
-    // Can I return something useful here instead of Empty?
-  }
-
-  rpc GetApiAddressess(google.protobuf.Empty) returns (google.protobuf.Empty) {}
+  rpc AddApiAccessMethod(ApiAccessMethod) returns (google.protobuf.Empty) {}
+  rpc RemoveApiAccessMethod(UUID) returns (google.protobuf.Empty) {}
+  rpc SetApiAccessMethod(UUID) returns (google.protobuf.Empty) {}
+  rpc UpdateApiAccessMethod(ApiAccessMethodUpdate) returns (google.protobuf.Empty) {}
 
   // Split tunneling (Linux)
   rpc GetSplitTunnelProcesses(google.protobuf.Empty) returns (stream google.protobuf.Int32Value) {}
diff --git a/mullvad-management-interface/src/client.rs b/mullvad-management-interface/src/client.rs
index c79b4d2d80..2503d6d55c 100644
--- a/mullvad-management-interface/src/client.rs
+++ b/mullvad-management-interface/src/client.rs
@@ -5,6 +5,7 @@ use futures::{Stream, StreamExt};
 use mullvad_types::{
     access_method::{daemon::ApiAccessMethodUpdate, ApiAccessMethod, ApiAccessMethodId},
     account::{AccountData, AccountToken, VoucherSubmission},
+    api_access::{ApiAccessMethod, ApiAccessMethodId},
     custom_list::{CustomList, Id},
     device::{Device, DeviceEvent, DeviceId, DeviceState, RemoveDeviceEvent},
     location::GeoIpLocation,
@@ -166,11 +167,13 @@ impl MullvadProxyClient {
 
     pub async fn get_api_access_methods(&mut self) -> Result<Vec<ApiAccessMethod>> {
         self.0
-            .get_api_access_methods(())
+            .get_settings(())
             .await
             .map_err(Error::Rpc)?
             .into_inner()
             .api_access_methods
+            .ok_or(Error::ApiAccessMethodSettingsNotFound)?
+            .api_access_methods
             .into_iter()
             .map(|api_access_method| {
                 ApiAccessMethod::try_from(api_access_method).map_err(Error::InvalidResponse)
@@ -182,18 +185,9 @@ impl MullvadProxyClient {
         &mut self,
         id: &ApiAccessMethodId,
     ) -> Result<ApiAccessMethod> {
-        self.0
-            .get_api_access_methods(())
-            .await
-            .map_err(Error::Rpc)?
-            .into_inner()
-            .api_access_methods
+        self.get_api_access_methods()
+            .await?
             .into_iter()
-            .map(|api_access_method| {
-                ApiAccessMethod::try_from(api_access_method)
-                    .map_err(Error::InvalidResponse)
-                    .expect("Failed to convert proto Api Access Method to daemon representation")
-            })
             .find(|api_access_method| api_access_method.get_id() == *id)
             .ok_or(Error::ApiAccessMethodNotFound)
     }
@@ -541,9 +535,12 @@ impl MullvadProxyClient {
             .map(drop)
     }
 
-    pub async fn remove_access_method(&mut self, api_access_method: ApiAccessMethod) -> Result<()> {
+    pub async fn remove_access_method(
+        &mut self,
+        api_access_method: ApiAccessMethodId,
+    ) -> Result<()> {
         self.0
-            .remove_api_access_method(types::ApiAccessMethod::from(api_access_method))
+            .remove_api_access_method(types::Uuid::from(api_access_method))
             .await
             .map_err(Error::Rpc)
             .map(drop)
diff --git a/mullvad-management-interface/src/lib.rs b/mullvad-management-interface/src/lib.rs
index 39d5f5df9d..c9414d03bf 100644
--- a/mullvad-management-interface/src/lib.rs
+++ b/mullvad-management-interface/src/lib.rs
@@ -104,6 +104,9 @@ pub enum Error {
     #[error(display = "Location was not found in the custom list")]
     LocationNotFoundInCustomlist,
 
+    #[error(display = "Could not retrieve API access methods from settings")]
+    ApiAccessMethodSettingsNotFound,
+
     #[error(display = "An access method with that id does not exist")]
     ApiAccessMethodNotFound,
 }
diff --git a/mullvad-management-interface/src/types/conversions/api_access_method.rs b/mullvad-management-interface/src/types/conversions/api_access_method.rs
index e72a4a1f97..fa0d346788 100644
--- a/mullvad-management-interface/src/types/conversions/api_access_method.rs
+++ b/mullvad-management-interface/src/types/conversions/api_access_method.rs
@@ -5,8 +5,8 @@ mod settings {
     use crate::types::{proto, FromProtobufTypeError};
     use mullvad_types::access_method;
 
-    impl From<&access_method::Settings> for proto::ApiAccessMethodSettings {
-        fn from(settings: &access_method::Settings) -> Self {
+    impl From<&api_access::Settings> for proto::ApiAccessMethodSettings {
+        fn from(settings: &api_access::Settings) -> Self {
             Self {
                 api_access_methods: settings
                     .api_access_methods
@@ -17,13 +17,13 @@ mod settings {
         }
     }
 
-    impl From<access_method::Settings> for proto::ApiAccessMethodSettings {
-        fn from(settings: access_method::Settings) -> Self {
+    impl From<api_access::Settings> for proto::ApiAccessMethodSettings {
+        fn from(settings: api_access::Settings) -> Self {
             proto::ApiAccessMethodSettings::from(&settings)
         }
     }
 
-    impl TryFrom<proto::ApiAccessMethodSettings> for access_method::Settings {
+    impl TryFrom<proto::ApiAccessMethodSettings> for api_access::Settings {
         type Error = FromProtobufTypeError;
 
         fn try_from(settings: proto::ApiAccessMethodSettings) -> Result<Self, Self::Error> {
@@ -31,8 +31,8 @@ mod settings {
                 api_access_methods: settings
                     .api_access_methods
                     .iter()
-                    .map(access_method::ApiAccessMethod::try_from)
-                    .collect::<Result<Vec<access_method::ApiAccessMethod>, _>>()?,
+                    .map(api_access::ApiAccessMethod::try_from)
+                    .collect::<Result<Vec<api_access::ApiAccessMethod>, _>>()?,
             })
         }
     }
@@ -55,14 +55,14 @@ mod settings {
                 .ok_or(FromProtobufTypeError::InvalidArgument(
                     "Could not convert Access Method from protobuf",
                 ))
-                .and_then(access_method::ApiAccessMethod::try_from)?;
+                .and_then(api_access::ApiAccessMethod::try_from)?;
 
             let id = value
                 .id
                 .ok_or(FromProtobufTypeError::InvalidArgument(
                     "Could not convert Access Method from protobuf",
                 ))
-                .map(access_method::ApiAccessMethodId::from)?;
+                .map(api_access::ApiAccessMethodId::from)?;
 
             Ok(access_method::daemon::ApiAccessMethodUpdate {
                 id,
@@ -77,7 +77,7 @@ mod settings {
 /// [`mullvad_types::access_method::AccessMethod`] data type.
 mod data {
     use crate::types::{proto, FromProtobufTypeError};
-    use mullvad_types::access_method::{
+    use mullvad_types::api_access::{
         AccessMethod, ApiAccessMethod, ApiAccessMethodId, BuiltInAccessMethod, CustomAccessMethod,
         Shadowsocks, Socks5, Socks5Local, Socks5Remote,
     };
@@ -243,12 +243,12 @@ mod data {
                     }
                 },
                 AccessMethod::BuiltIn(value) => match value {
-                    mullvad_types::access_method::BuiltInAccessMethod::Direct => {
+                    mullvad_types::api_access::BuiltInAccessMethod::Direct => {
                         proto::api_access_method::AccessMethod::Direct(
                             proto::api_access_method::Direct {},
                         )
                     }
-                    mullvad_types::access_method::BuiltInAccessMethod::Bridge => {
+                    mullvad_types::api_access::BuiltInAccessMethod::Bridge => {
                         proto::api_access_method::AccessMethod::Bridges(
                             proto::api_access_method::Bridges {},
                         )
diff --git a/mullvad-management-interface/src/types/conversions/settings.rs b/mullvad-management-interface/src/types/conversions/settings.rs
index 98c195d935..532e5e8f29 100644
--- a/mullvad-management-interface/src/types/conversions/settings.rs
+++ b/mullvad-management-interface/src/types/conversions/settings.rs
@@ -180,7 +180,7 @@ impl TryFrom<proto::Settings> for mullvad_types::settings::Settings {
             custom_lists: mullvad_types::custom_list::CustomListsSettings::try_from(
                 custom_lists_settings,
             )?,
-            api_access_methods: mullvad_types::access_method::Settings::try_from(
+            api_access_methods: mullvad_types::api_access::Settings::try_from(
                 api_access_methods_settings,
             )?,
         })
diff --git a/mullvad-management-interface/src/types/rpc/api_access_method_update.rs b/mullvad-management-interface/src/types/rpc/api_access_method_update.rs
new file mode 100644
index 0000000000..b270893102
--- /dev/null
+++ b/mullvad-management-interface/src/types/rpc/api_access_method_update.rs
@@ -0,0 +1,8 @@
+/// A short-lived datastructure used in the `ApiAccessMethodUpdate` RPC call.
+use mullvad_types::api_access::{ApiAccessMethod, ApiAccessMethodId};
+/// Argument to gRPC call `UpdateApiAccessMethod`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ApiAccessMethodUpdate {
+    pub id: ApiAccessMethodId,
+    pub access_method: ApiAccessMethod,
+}
diff --git a/mullvad-types/src/access_method.rs b/mullvad-types/src/api_access.rs
index db591efd3b..c20a1fe7fd 100644
--- a/mullvad-types/src/access_method.rs
+++ b/mullvad-types/src/api_access.rs
@@ -11,19 +11,16 @@ pub struct Settings {
 
 impl Settings {
     /// Append an [`AccessMethod`] to the end of `api_access_methods`.
-    #[inline(always)]
     pub fn append(&mut self, api_access_method: ApiAccessMethod) {
         self.api_access_methods.push(api_access_method)
     }
 
     /// Remove an [`ApiAccessMethod`] from `api_access_methods`.
-    #[inline(always)]
     pub fn remove(&mut self, api_access_method: &ApiAccessMethodId) {
         self.retain(|method| method.get_id() != *api_access_method)
     }
 
     /// Search for a particular [`AccessMethod`] in `api_access_methods`.
-    #[inline(always)]
     pub fn find(&self, element: &ApiAccessMethodId) -> Option<&ApiAccessMethod> {
         self.api_access_methods
             .iter()
@@ -35,7 +32,6 @@ impl Settings {
     /// If the [`AccessMethod`] is found to be part of `api_access_methods`, a
     /// mutable reference to that inner element is returned. Otherwise, `None`
     /// is returned.
-    #[inline(always)]
     pub fn find_mut(&mut self, element: &ApiAccessMethodId) -> Option<&mut ApiAccessMethod> {
         self.api_access_methods
             .iter_mut()
@@ -43,7 +39,6 @@ impl Settings {
     }
 
     /// Equivalent to [`Vec::retain`].
-    #[inline(always)]
     pub fn retain<F>(&mut self, f: F)
     where
         F: FnMut(&ApiAccessMethod) -> bool,
@@ -52,7 +47,6 @@ impl Settings {
     }
 
     /// Clone the content of `api_access_methods`.
-    #[inline(always)]
     pub fn cloned(&self) -> Vec<ApiAccessMethod> {
         self.api_access_methods.clone()
     }
@@ -165,6 +159,10 @@ impl ApiAccessMethod {
         self.access_method.as_custom()
     }
 
+    pub fn is_builtin(&self) -> bool {
+        self.as_custom().is_none()
+    }
+
     /// Set an API access method to be enabled.
     pub fn enable(&mut self) {
         self.enabled = true;
diff --git a/mullvad-types/src/lib.rs b/mullvad-types/src/lib.rs
index 8aefaeb400..e1af195220 100644
--- a/mullvad-types/src/lib.rs
+++ b/mullvad-types/src/lib.rs
@@ -1,7 +1,7 @@
 #![deny(rust_2018_idioms)]
 
-pub mod access_method;
 pub mod account;
+pub mod api_access;
 pub mod auth_failed;
 pub mod custom_list;
 pub mod device;
diff --git a/mullvad-types/src/settings/mod.rs b/mullvad-types/src/settings/mod.rs
index 6ade7dea32..2c40172a2c 100644
--- a/mullvad-types/src/settings/mod.rs
+++ b/mullvad-types/src/settings/mod.rs
@@ -1,5 +1,5 @@
 use crate::{
-    access_method,
+    api_access,
     custom_list::CustomListsSettings,
     relay_constraints::{
         BridgeConstraints, BridgeSettings, BridgeState, Constraint, GeographicLocationConstraint,
@@ -79,7 +79,7 @@ pub struct Settings {
     pub custom_lists: CustomListsSettings,
     /// API access methods.
     #[cfg_attr(target_os = "android", jnix(skip))]
-    pub api_access_methods: access_method::Settings,
+    pub api_access_methods: api_access::Settings,
     /// If the daemon should allow communication with private (LAN) networks.
     pub allow_lan: bool,
     /// Extra level of kill switch. When this setting is on, the disconnected state will block
@@ -140,7 +140,7 @@ impl Default for Settings {
             split_tunnel: SplitTunnelSettings::default(),
             settings_version: CURRENT_SETTINGS_VERSION,
             custom_lists: CustomListsSettings::default(),
-            api_access_methods: access_method::Settings::default(),
+            api_access_methods: api_access::Settings::default(),
         }
     }
 }